unbounded 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c98cc5d255568b4124a3ae5e87269348e2971136
+  data.tar.gz: ae0242ba93586dc599b2bf606b216dddcd19054b
+SHA512:
+  metadata.gz: 0fcc4b3258a7fd16b7c193c342f99e6c271bdb6a2be04e5e5b822d7471f46ef8c030ed4c6d8b259c7e2f8c6600a19e05d4dad1edf25b416f8556322698027fa8
+  data.tar.gz: 4e72d60a82c534ba8b1d84cc833900c473de8f62b19293b5a2f89dbf06f5e7bcc8ffa9c05f165c1ad2971e8aa8fb89b025ae66ec5e42a0ae18c74f7db514d55c

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.pryrc

@@ -0,0 +1,4 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'unbounded/version'
+require 'unbounded'

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.yardopts

@@ -0,0 +1,5 @@
+--protected
+--private
+lib/**/*.rb
+-M redcarpet
+-m markdown

data/Gemfile

@@ -0,0 +1,5 @@
+# encoding: utf-8
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in unbounded.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Alexa Grey
+
+MIT License
+
+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,57 @@
+# Unbounded
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'unbounded'
+```
+
+And then execute:
+
+```shell
+bundle
+```
+
+Or install it yourself as:
+
+```shell
+gem install unbounded
+```
+
+## Usage
+
+Create an unbounded range by passing nil as one of the end points:
+
+```ruby
+normal_style = Unbounded::Range.new(0, nil) # => 0..INFINITY
+```
+
+... Or using postgres-style ranges
+
+```ruby
+postgres_style = Unbounded::Range.new('[0,100)') # => 0...100
+```
+
+Alternatively, convert a vanilla range:
+
+```ruby
+converted = (1..3).unbounded
+converted.kind_of? Unbounded::Range # => true
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Todo
+
+* invertable ranges (at least for numeric)
+

data/Rakefile

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require "bundler/gem_tasks"
+
+require "rspec/core/rake_task"
+require 'yard'
+
+RSpec::Core::RakeTask.new('spec')
+
+desc 'Generate docs'
+YARD::Rake::YardocTask.new(:doc) do |t|
+  t.files = ['lib/**/*.rb']
+  t.options = ['--protected', '--private', '-r', 'README.md']
+end
+
+namespace :doc do
+  desc 'Generate and publish YARD docs to github pages.'
+  task :publish => ['doc'] do
+    Dir.chdir(File.dirname(__FILE__) + '/../doc') do
+      system %Q{git add .}
+      system %Q{git add -u}
+      system %Q{git commit -m 'Generating docs for version #{version}.'}
+      system %Q{git push origin gh-pages}
+    end
+  end
+end
+
+task :default => :spec

data/lib/unbounded/formats.rb

@@ -0,0 +1,110 @@
+# encoding: utf-8
+
+module Unbounded
+  # Methods for parsing alternative range formats
+  # Presently there are two:
+  #
+  # * {POSTGRES_FORMAT}
+  # * {SIMPLE_FORMAT}
+  module Formats
+    extend ActiveSupport::Concern
+
+    # @!parse include Unbounded::Utility
+    include Unbounded::Utility
+
+    # A regular expression that loosely describes the format used within Postgres
+    # for their range types. They look something like:
+    #
+    # * `"[4,6]"` == `4..6`
+    # * `"[1,9)"` == `1...9`
+    #
+    # An endpoint can be omitted to create an unbounded type:
+    #
+    # * `"[1,]"` == `1..INFINITY`
+    # * `"[,0)"` == `-INFINITY...0`
+    #
+    # @see http://www.postgresql.org/docs/9.2/static/rangetypes.html for more information
+    # @return [Regexp] 
+    POSTGRES_FORMAT=/^
+      (?<lower_inc>[\[\(])
+        (?<minimum>\S*)
+          ,\s*
+        (?<maximum>\S*)
+      (?<upper_inc>[\)\]])
+    $/x
+
+    # A regular expression for parsing the simple format used in
+    # Range.new shorthand, e.g. `'1..3'`, `'4...10'`
+    # @return [Regexp]
+    SIMPLE_FORMAT=/^(?<minimum>[^\.]+)(?<inclusiveness>\.\.\.?)(?<maximum>[^\.]+)$/
+
+    # @param  [Array] args arguments from {Unbounded::Range#initialize}
+    # @return [OpenStruct]
+    def parse_for_range(args)
+      hashed = case args.length
+      when 0    then parse_standard_range_options(nil, nil)
+      when 1    then parse_string_for_range_options(args.shift)
+      when 2..3 then parse_standard_range_options(*args)
+      end.presence or raise ArgumentError, "Don't know how to parse arguments: #{args.inspect}"
+
+
+      OpenStruct.new(hashed).tap do |o|
+        if o.format == :postgres
+          alter_by_postgres_style! o
+        elsif o.format == :simple
+          alter_by_simple_style! o
+        end
+      end
+    end
+
+    private
+    # Parse the standard range initialization options
+    # @see Range#initialize
+    # @param [Object] min
+    # @param [Object] max
+    # @param [Boolean] exclude_end
+    # @return [{format: :standard, minimum: Numeric, maximum: Numeric, exclude_end: Boolean}]
+    def parse_standard_range_options(min, max, exclude_end = false)
+      {
+        :format => :standard,
+        :minimum => min.presence || NINFINITY,
+        :maximum => max.presence || INFINITY,
+        :exclude_end => !!exclude_end
+      }
+    end
+
+    # Parse string using {POSTGRES_FORMAT} or {SIMPLE_FORMAT}.
+    # @param  [#to_s] s
+    # @return [Hash]
+    def parse_string_for_range_options(s)
+      case s.to_s
+      when POSTGRES_FORMAT
+        match_to_hash(Regexp.last_match).merge(:format => :postgres)
+      when SIMPLE_FORMAT
+        match_to_hash(Regexp.last_match).merge(:format => :simple)
+      end
+    end
+
+    # Modify the options slightly for postgres formats.
+    # @param [OpenStruct] options
+    # @return [void]
+    def alter_by_postgres_style!(options)
+      options.minimum     = numerify(options.minimum, NINFINITY)
+      options.maximum     = numerify(options.maximum, INFINITY)
+      options.exclude_end = options.upper_inc == ')'
+
+      if options.lower_inc == '('
+        options.minimum += 1
+      end
+    end
+
+    # Modify the options slightly to account for simple (e.g. 1..3) formatting
+    # @param [OpenStruct] options
+    # @return [void]
+    def alter_by_simple_style!(options)
+      options.minimum     = numerify(options.minimum, NINFINITY)
+      options.maximum     = numerify(options.maximum, INFINITY)
+      options.exclude_end = options.inclusiveness.length == 3
+    end
+  end
+end

data/lib/unbounded/infinite_enumerator.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+module Unbounded
+  # An error created when attempting to iterate over a (non-lazy)
+  # version of an {Unbounded::Range}, and the current ruby version
+  # does not support `#lazy`.
+
+  class InfiniteEnumerator < TypeError
+  end
+end

data/lib/unbounded/range.rb

@@ -0,0 +1,188 @@
+# encoding: utf-8
+
+module Unbounded
+  # An unbounded (infinite) range extension for the standard Ruby Range class.
+  class Range < ::Range
+    include Formats
+
+    RANGE_FORMATS[:humanized] = proc { |first, last| ::Unbounded::Range.humanized(first, last) }
+    RANGE_FORMATS[:postgres]  = proc { |first, last| ::Unbounded::Range.postgres(first, last) }
+
+    # @overload initialize(range_start, range_minimum, exclude_end = false)
+    #   Create a range the traditional way, à la `Range.new`.
+    #   @param [#succ] range_start
+    #   @param [#succ] range_end
+    #   @param [Boolean] exclude_end
+    # @overload initialize(range_string)
+    #   Create a range in the same manner as you would in PostgreSQL
+    #   @param [String] range_string
+    def initialize(*args)
+      parsed = parse_for_range(args)
+
+      @format = parsed.format
+
+      super(parsed.minimum, parsed.maximum, parsed.exclude_end)
+    end
+
+    # @todo i18n support
+    # @return [String] a more human-readable format
+    def humanized
+      case unbounded?
+      when :infinite
+        "infinite"
+      when :maximum
+        "#{self.begin}+"
+      when :minimum
+        exclude_end? ? "fewer than #{self.end}" : "#{self.end} or fewer"
+      else
+        super
+      end
+    end
+
+    # @return [Boolean]
+    def infinite?
+      numeric? && ( ( unbounded_minimum | unbounded_maximum ) == 3 )
+    end
+
+    # @return [Boolean] whether this range is numeric
+    def numeric?
+      self.begin.kind_of?(Numeric) && self.end.kind_of?(Numeric)
+    end
+
+    # For compatibility with {Unbounded::RangeExtension#unbounded}
+    # unded?
+    # @return [self]
+    def unbounded
+      self
+    end
+
+    # Check whether this range is unbounded in some way.
+    # @return [Symbol,nil] returns a symbol for the type of unboundedness, nil otherwise
+    def unbounded?(unbounded_type = nil)
+      return false unless numeric?
+
+      unboundedness = case unbounded_minimum | unbounded_maximum
+      when 3 then :infinite
+      when 2 then :maximum
+      when 1 then :minimum
+      end
+
+      return unbounded_type && unboundedness ? ( unboundedness == :infinite ) || ( unboundedness == unbounded_type ) : unboundedness
+    end
+
+    # @!group Enumerable Overrides
+    # Same as `Enumerable#count`, except in cases where the collection is {Range#unbounded?}.
+    # @note This would not be true in some cases, e.g. checking for negative
+    #   numbers on a range of 0 to infinity.
+    # @return [Integer, INFINITY] Infinity when unbounded, super otherwise
+    def count(*args, &block)
+      unbounded? ? INFINITY : super
+    end
+
+    # @overload first
+    #   @return [Numeric] equivalent to `#min`
+    # @overload first(n)
+    #   @param [Integer] n
+    #   @return [Array<#succ>] first n-elements of the range
+    def first(*args)
+      n = args.shift
+
+      if unbounded_minimum? && (n.nil? || n.kind_of?(Integer))
+        if n.nil?
+          min
+        else
+          Array.new(n, min)
+        end
+      else
+        return n.nil? ? super() : super(n)
+      end
+    end
+
+    # @overload last
+    #   @return [Numeric] equivalent to {#max}
+    # @overload last(n)
+    #   @param  [Integer] n
+    #   @return [Array<#succ>] last n-elements of the range
+    def last(*args)
+      n = args.shift
+
+      if unbounded? && (n.nil? || n.kind_of?(Integer))
+        if n.nil?
+          max
+        elsif unbounded? == :minimum # To prevent `cannot iterate from Float`
+          new_minimum = max - (n - 1)
+
+          (new_minimum..max).to_a
+        else
+          Array.new(n, max) # Array of Infinity
+        end
+      else
+        return n.nil? ? super() : super(n)
+      end
+    end
+
+    # Overload for `Range#max` to account for "unbounded_maximum? && exclude_end?" edge case
+    def max
+      super
+    rescue TypeError
+      self.end
+    end
+
+    # The default implementation of `Range#minmax` for needlessly uses `#each`,
+    # which can cause infinite enumeration.
+    # @return [Array(Numeric, Numeric)]
+    def minmax
+      [min, unbounded? ? INFINITY : max]
+    end
+    # @!endgroup
+
+    class << self
+      # @param [Numeric] first
+      # @param [Numeric] last
+      # @return [String]
+      def humanized(first, last)
+        return new(first, last).humanized
+      end
+
+      private
+      # @param [Symbol] type should be :min or :max
+      # @param [Integer] int_to_return integer to return for bitwise comparison in {#unbounded?}
+      # @return [void]
+      # @!macro [attach] unbounded_endpoint
+      #   @!method unbounded_$1imum
+      #     Determine whether the $1 is unbounded.
+      #     @!visibility private
+      #     @return [$2,0] $2 if unbounded, 0 if otherwise
+      #
+      #   @!method unbounded_$1imum?
+      #     Predicate method for {#unbounded_$1imum} that checks against zero
+      #     @return [Integer,nil]
+      #
+      #   @!method finite_$1imum?
+      #     Inverse complement of {#unbounded_$1imum?}
+      #     @return [Boolean]
+      def unbounded_endpoint(type, int_to_return)
+        attr_name = type == :min ? "begin" : "end"
+
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def unbounded_#{type}imum
+            self.#{attr_name}.respond_to?(:infinite?) && self.#{attr_name}.infinite? ? #{int_to_return} : 0
+          end
+
+          def unbounded_#{type}imum?
+            unbounded_#{type}imum.nonzero?
+          end
+
+          def finite_#{type}imum?
+            !unbounded_#{type}imum?
+          end
+
+          private :unbounded_#{type}imum
+        RUBY
+      end
+    end
+
+    unbounded_endpoint :min, 1
+    unbounded_endpoint :max, 2
+  end
+end

data/lib/unbounded/range_extension.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module Unbounded
+  # Extensions for the standard Ruby `Range` class.
+  module RangeExtension
+    extend ::ActiveSupport::Concern
+
+    # @return [String] humanized string of the range
+    def humanized
+      "#{self.begin} \u2013 #{self.end}"
+    end
+
+    # Transform this into an Unbounded::Range.
+    # @return [Unbounded::Range]
+    def unbounded
+      ::Unbounded::Range.new(self.min, self.max, exclude_end?)
+    end
+  end
+end
+
+Range.send(:include, Unbounded::RangeExtension)

data/lib/unbounded/utility.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+module Unbounded
+  # Shared utility methods
+  module Utility
+    extend ActiveSupport::Concern
+
+    # Convert matchdata to a hash.
+    # @param [MatchData] match
+    # @return [Hash]
+    def match_to_hash(match)
+      Hash[match.names.zip(match.captures)]
+    end
+
+    # @param [Object] thing something to numerify
+    # @param [Object] default_value a value to return if `thing` fails to numerify.
+    #   If it is `:original`, it will return the value of `thing` as-is.
+    # @return [Numeric, Object, nil]
+    def numerify(thing, default_value = nil)
+      return thing if thing.is_a?(Numeric)
+
+      if thing.respond_to?(:include?) && thing.include?('.')
+        Float(thing)
+      else
+        Integer(thing)
+      end
+    rescue ArgumentError, TypeError
+      if default_value == :original
+        thing
+      else
+        default_value
+      end
+    end
+
+    extend self
+  end
+end

data/lib/unbounded/version.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+module Unbounded
+  # Current library version.
+  # @return [Gem::Version]
+  VERSION = Gem::Version.new("0.0.1")
+end

data/lib/unbounded.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require 'active_support/concern'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/object/try'
+require 'active_support/core_ext/range'
+
+require 'ostruct'
+
+require 'unbounded/version'
+
+# A library for working with unbounded (infinite) ranges,
+# with support for PostgreSQL-style notation.
+module Unbounded
+  # Infinity
+  INFINITY = 1.0 / 0.0
+
+  # Negative infinity
+  NINFINITY = -INFINITY
+
+  autoload :Formats,            'unbounded/formats'
+  autoload :InfiniteEnumerator, 'unbounded/infinite_enumerator'
+  autoload :Range,              'unbounded/range'
+  autoload :Utility,            'unbounded/utility'
+
+  require 'unbounded/range_extension'
+
+  # @!parse extend Unbounded::Utility
+  extend Unbounded::Utility
+
+  # @return [Unbounded::Range]
+  def Unbounded.range(*args, &block)
+    Unbounded::Range.new(*args, &block)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'simplecov'
+SimpleCov.start
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+require 'bundler/setup'
+require 'unbounded'
+require 'pry'
+
+Dir["./spec/support/**/*.rb"].sort.each {|f| require f }
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.alias_it_should_behave_like_to :it_has_behavior, 'has behavior:'
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/support/shared_context_for_postgres_style_ranges.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+shared_context 'postgres', pg: :true do
+  subject { described_class.new example.metadata[:postgres] }
+
+  let(:equivalent_range) { example.metadata[:equiv] }
+
+  it '== an equivalent range' do
+    should == equivalent_range
+  end
+
+  it_behaves_like 'postgres range exclusivity'
+end

data/spec/support/shared_examples_for_a_finite_maximum.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+shared_examples_for 'a finite maximum' do
+  describe '#last' do
+    specify 'given no parameters, it returns max' do
+      subject.last.should eq subject.max
+    end
+
+    specify 'given an integer, it defers to super' do
+      subject.last(10).should be_a_kind_of Array
+    end
+  end
+end

data/spec/support/shared_examples_for_a_finite_minimum.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+shared_examples_for 'a finite minimum' do
+  describe '#first' do
+    specify 'given no parameters, it returns #min' do
+      subject.first.should == subject.min
+    end
+
+    specify 'given an integer, it defers to super' do
+      subject.first(10).should be_a_kind_of Array
+    end
+  end
+end

data/spec/support/shared_examples_for_an_excluded_end.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+shared_examples_for 'an excluded end' do
+  it { should be_exclude_end }
+
+  it { should_not include subject.end }
+end

data/spec/support/shared_examples_for_an_infinite_range.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+shared_examples_for 'an infinite range' do
+  it { should be_infinite }
+
+  it_has_behavior 'humanized (infinite)'
+
+  it 'it should include any number' do
+    should include infinity, negative_infinity, *(positive_numbers + negative_numbers)
+  end
+
+  it_should_behave_like 'any unbounded range'
+end

data/spec/support/shared_examples_for_an_unbounded_maximum.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+shared_examples_for 'an unbounded maximum' do
+  it_should_behave_like 'any unbounded range'
+
+  it_has_behavior 'humanized (n+)'
+
+  it 'should include any positive number' do
+    should include *positive_numbers
+  end
+
+  it 'should not include negative numbers' do
+    should_not include *negative_numbers
+  end
+
+  describe '#last' do
+    specify 'given no parameters, it should be INFINITY' do
+      subject.last.should == infinity
+    end
+
+    specify 'given an integer, it returns Array.new(n, INFINITY)' do
+      subject.last(10).should == Array.new(10, infinity)
+    end
+  end
+end

data/spec/support/shared_examples_for_an_unbounded_minimum.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+shared_examples_for 'an unbounded minimum' do
+  it_should_behave_like 'any unbounded range'
+
+  it 'should include any negative number' do
+    should include *negative_numbers
+  end
+
+  it 'should not include positive numbers' do
+    should_not include *positive_numbers
+  end
+
+  describe '#first' do
+    specify 'given no parameters, it should be -INFINITY' do
+      subject.first.should == negative_infinity
+    end
+
+    specify 'given an integer, it returns Array.new(n, -INFINITY)' do
+      subject.first(10).should == Array.new(10, negative_infinity)
+    end
+  end
+end

data/spec/support/shared_examples_for_any_unbounded_range.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+shared_examples_for 'any unbounded range' do
+  it { should be_unbounded }
+
+  it { should be_numeric }
+
+  describe '#count' do
+    its(:count) { should be_infinite }
+  end
+end

data/spec/support/shared_examples_for_humanized_string.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+shared_examples_for 'humanized string' do
+  describe '#humanized' do
+    it 'humanizes correctly' do
+      subject.humanized.should match expected_format
+    end
+  end
+end
+
+shared_examples_for 'humanized (n or fewer)' do
+  let(:expected_format) { %r,\d+ or fewer, }
+  include_examples 'humanized string'
+end
+
+shared_examples_for "humanized (hyphenated)" do
+  let(:expected_format) { %r,\d+ #{"\u2013"} \d+, }
+  include_examples 'humanized string'
+end
+
+shared_examples_for 'humanized (fewer than n)' do
+  let(:expected_format) { %r,fewer than \d+, }
+  include_examples 'humanized string'
+end
+
+shared_examples_for 'humanized (infinite)' do
+  let(:expected_format) { %r,infinite, }
+  include_examples 'humanized string'
+end
+
+shared_examples_for 'humanized (n+)' do
+  let(:expected_format) { %r,\d+\+, }
+  include_examples 'humanized string'
+end

data/spec/support/shared_examples_for_numerification.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+shared_examples_for 'numerification' do |opts = {}|
+  if opts.key?(:want)
+    let(:wanted) { opts[:want] }
+
+    it 'converts to the expected value' do
+      should == wanted
+    end
+  elsif opts.key?(:default)
+    if opts[:default] == :original
+      it 'should return the original' do
+        should eq provided
+      end
+    else
+      it 'returns the default' do
+        should eq default
+      end
+    end
+  else
+    it 'returns nil' do
+      should be_nil
+    end
+  end
+
+  let(:provided) do
+    opts.fetch(:provide) do
+      opts.fetch(:want).presence.to_s
+    end
+  end
+
+  let (:default) { opts[:default] }
+
+  subject { dummy_class.numerify(provided, default) }
+
+  if opts.key? :klass
+    let(:klass) { opts[:klass] }
+
+    it "coerces to a #{opts[:klass]}" do
+      should be_a_kind_of klass
+    end
+  end
+
+end

data/spec/support/shared_examples_for_postgres_range_exclusivity.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+shared_examples_for 'postgres range exclusivity' do |*args|
+  exclusivity = args.shift || {}
+
+  exclusivity = OpenStruct.new exclusivity
+
+  exclusivity.max = metadata.fetch(:postgres, '').end_with?(')') if exclusivity.min.nil?
+
+  exclusivity.min = metadata.fetch(:postgres, '').start_with?('(') if exclusivity.min.nil?
+
+  let!(:provided_range_start) { ( example.metadata.fetch(:postgres, '')[/^.(\d)+,/, 1] || 0).to_i }
+
+  let!(:expected_range_start) { provided_range_start + (exclusivity.min ? 1 : 0) }
+
+  if exclusivity.min
+    specify 'it should have a different start than provided' do
+      subject.min.should_not == provided_range_start
+      subject.min.should == expected_range_start
+    end
+
+    specify 'it should not include the provided minimum' do
+      subject.should_not include provided_range_start
+    end
+  else
+
+    specify 'it should have the provided minimum' do
+      subject.min.should == provided_range_start
+    end
+  
+  end
+
+  if exclusivity.max
+    specify 'the end is excluded' do
+      subject.should_not include subject.end
+    end
+  else
+    specify 'the end is included' do
+      subject.should include subject.max
+    end
+  end
+
+  its(:exclude_end?) { should exclusivity.max ? be_true : be_false }
+end

data/spec/unbounded/range_extension_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Unbounded::RangeExtension do
+  let(:standard_range) { 1..10 }
+
+  subject { standard_range }
+
+  it_has_behavior 'humanized (hyphenated)'
+
+  describe '#unbounded' do
+    its(:unbounded) { should be_a_kind_of Unbounded::Range }
+    its(:unbounded) { should == standard_range }
+  end
+end

data/spec/unbounded/range_spec.rb

@@ -0,0 +1,127 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Unbounded::Range do
+  let(:negative_infinity) { Unbounded::NINFINITY }
+  let(:infinity)          { Unbounded::INFINITY }
+  let(:positive_numbers)  { [42, 2**64] }
+  let(:negative_numbers)  { [-2**64, -42] }
+
+  describe '#unbounded' do
+    specify 'returns self' do
+      subject.unbounded.should be subject
+    end
+  end
+
+  describe '.humanized' do
+    specify { described_class.humanized(0, 10).should be_a_kind_of String }
+  end
+
+  describe '.new' do
+    context 'given ()' do
+      it_should_behave_like 'an infinite range'
+    end
+
+    context 'given (nil, nil)' do
+      subject { described_class.new nil, nil }
+
+      it_should_behave_like 'an infinite range'
+    end
+
+    context 'given (0, nil)' do
+      subject { described_class.new 0, nil }
+
+      it_should_behave_like 'a finite minimum'
+
+      it_should_behave_like 'an unbounded maximum'
+
+      it_has_behavior 'humanized (n+)'
+    end
+
+    context 'given (0, nil, true)' do
+      subject { described_class.new 0, nil, true }
+      
+      it_should_behave_like 'an excluded end'
+
+      it_should_behave_like 'a finite minimum'
+
+      it_should_behave_like 'an unbounded maximum'
+
+      it_has_behavior 'humanized (n+)'
+
+      describe '#minmax' do
+        specify 'the last element is infinity' do
+          subject.minmax.last == infinity
+        end
+      end
+    end
+
+    context 'given (nil, 0)' do
+      subject { described_class.new nil, 0 }
+
+      it_should_behave_like 'an unbounded minimum'
+
+      it_should_behave_like 'a finite maximum'
+      
+      it_has_behavior 'humanized (n or fewer)'
+    end
+
+    context 'given (nil, 0, true)' do
+      subject { described_class.new nil, 0, true }
+
+      it_should_behave_like 'an excluded end'
+
+      it_should_behave_like 'an unbounded minimum'
+
+      it_should_behave_like 'a finite maximum'
+
+      it_has_behavior 'humanized (fewer than n)'
+    end
+
+    context 'with a postgres-style string argument' do
+      context '()', :pg,
+        :start_excluded,
+        :end_excluded,
+        postgres: '(1,10)',
+        equiv: 2...10
+
+      context '[)', :pg,
+        :end_excluded,
+        start_excluded: false,
+        postgres: '[1,10)',
+        equiv: 1...10
+
+      context '(]', :pg,
+        :start_excluded,
+        end_excluded: false,
+        postgres: '(1,10]',
+        equiv: 2..10
+
+      context '[]', :pg,
+        end_excluded: false,
+        start_excluded: false,
+        postgres: '[1,10]',
+        equiv: 1..10
+    end
+
+    context 'with a simple-style string argument' do
+      context 'given 0...Infinity' do
+        subject { described_class.new('0...Infinity') }
+
+        it_should_behave_like 'a finite minimum'
+        it_should_behave_like 'an unbounded maximum'
+        it_should_behave_like 'an excluded end'
+      end
+
+      context 'given 1..10' do
+        subject { described_class.new('1..10') }
+
+        it_should_behave_like 'a finite minimum'
+        it_should_behave_like 'a finite maximum'
+
+        it_has_behavior 'humanized (hyphenated)'
+      end
+    end
+  end
+end

data/spec/unbounded/utility_spec.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Unbounded::Utility do
+  let(:dummy_class) { Module.new { extend Unbounded::Utility } }
+
+  describe '#match_to_hash' do
+    let(:regex) { %r:^(?<first_word>\w+)[^\w]*(?<second_word>\w+): }
+    let(:test_string) { 'Hello, world!' }
+    let(:match_data) { test_string.match(regex) }
+
+    subject { dummy_class.match_to_hash(match_data) }
+
+    it 'converts `MatchData` to a hash' do
+      subject.should be_a_kind_of Hash
+    end
+
+    it 'has the expected contents' do
+      should include 'first_word' => 'Hello', 'second_word' => 'world'
+    end
+  end
+
+  describe '#numerify' do
+    context 'given a numeric value' do
+      it 'returns the same' do
+        dummy_class.numerify(1).should eq 1
+        dummy_class.numerify(2.0).should eq 2.0
+      end
+    end
+
+    context 'given a float-containing string' do
+      it_has_behavior 'numerification', :want => 1.0, :klass => Float
+    end
+
+    context 'given an integer-containing string' do
+      it_has_behavior 'numerification', :want => 1, :klass => Integer
+    end
+
+    context 'on a failed conversion' do
+      context 'given no default' do
+        it_has_behavior 'numerification', :provide => 'anything else'
+      end
+
+      context 'default: :original' do
+        it_has_behavior 'numerification', :provide => 'some string', :default => :original
+      end
+
+      context 'default: some other string' do
+        it_has_behavior 'numerification', :provide => 'some string', :default => 'some other string'
+      end
+    end
+  end
+end

data/spec/unbounded_spec.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Unbounded do
+  describe '.range' do
+    specify 'creates a range' do
+      described_class.range(nil, nil).should be_a_kind_of Unbounded::Range
+    end
+  end
+end

data/unbounded.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'unbounded/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "unbounded"
+  spec.version       = Unbounded::VERSION
+  spec.authors       = ["Alexa Grey"]
+  spec.email         = ["devel@mouse.vc"]
+  spec.description   = %q{Unbounded (infinite) ranges, ruby-style}
+  spec.summary       = %q{Unbounded (infinite) ranges, ruby-style}
+  spec.homepage      = "https://github.com/scryptmouse/unbounded"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "active_support", ">= 3.0"
+
+  spec.add_development_dependency "bundler",  "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec",    "~> 2.14"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency 'yard'
+end

metadata

@@ -0,0 +1,191 @@
+--- !ruby/object:Gem::Specification
+name: unbounded
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Alexa Grey
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: active_support
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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: simplecov
+  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: yard
+  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: Unbounded (infinite) ranges, ruby-style
+email:
+- devel@mouse.vc
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .pryrc
+- .rspec
+- .yardopts
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/unbounded.rb
+- lib/unbounded/formats.rb
+- lib/unbounded/infinite_enumerator.rb
+- lib/unbounded/range.rb
+- lib/unbounded/range_extension.rb
+- lib/unbounded/utility.rb
+- lib/unbounded/version.rb
+- spec/spec_helper.rb
+- spec/support/shared_context_for_postgres_style_ranges.rb
+- spec/support/shared_examples_for_a_finite_maximum.rb
+- spec/support/shared_examples_for_a_finite_minimum.rb
+- spec/support/shared_examples_for_an_excluded_end.rb
+- spec/support/shared_examples_for_an_infinite_range.rb
+- spec/support/shared_examples_for_an_unbounded_maximum.rb
+- spec/support/shared_examples_for_an_unbounded_minimum.rb
+- spec/support/shared_examples_for_any_unbounded_range.rb
+- spec/support/shared_examples_for_humanized_string.rb
+- spec/support/shared_examples_for_numerification.rb
+- spec/support/shared_examples_for_postgres_range_exclusivity.rb
+- spec/unbounded/range_extension_spec.rb
+- spec/unbounded/range_spec.rb
+- spec/unbounded/utility_spec.rb
+- spec/unbounded_spec.rb
+- unbounded.gemspec
+homepage: https://github.com/scryptmouse/unbounded
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Unbounded (infinite) ranges, ruby-style
+test_files:
+- spec/spec_helper.rb
+- spec/support/shared_context_for_postgres_style_ranges.rb
+- spec/support/shared_examples_for_a_finite_maximum.rb
+- spec/support/shared_examples_for_a_finite_minimum.rb
+- spec/support/shared_examples_for_an_excluded_end.rb
+- spec/support/shared_examples_for_an_infinite_range.rb
+- spec/support/shared_examples_for_an_unbounded_maximum.rb
+- spec/support/shared_examples_for_an_unbounded_minimum.rb
+- spec/support/shared_examples_for_any_unbounded_range.rb
+- spec/support/shared_examples_for_humanized_string.rb
+- spec/support/shared_examples_for_numerification.rb
+- spec/support/shared_examples_for_postgres_range_exclusivity.rb
+- spec/unbounded/range_extension_spec.rb
+- spec/unbounded/range_spec.rb
+- spec/unbounded/utility_spec.rb
+- spec/unbounded_spec.rb
+has_rdoc: