boundy 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+--- 
+SHA1: 
+  metadata.gz: 55bb89b47f6477f182a1e2f5dc6409a386a3593c
+  data.tar.gz: e54945d291b401d501003dacce33a5696dae01d2
+SHA512: 
+  metadata.gz: 80d51de835f5509772835a640a17c0c98b8c8d010cfcaf65ab22ebf54b61d1b97f2415898424092365414c01e167124fee92cefe2a824ae8124baee91989b640
+  data.tar.gz: 775bb5bdfaedf3247ab54a4e39ad23a6b94b70a7dcbd45ab1a6f5037a9f4046d76af55d41d3a72c06b94e58a58954e8447bf9e59c2c9371ab5d3180a8f9c6b45

data/lib/boundy.rb

@@ -0,0 +1,19 @@
+module Boundy
+
+  class << self
+    def logger
+      return @logger if @logger
+
+      @logger = Logger.new(STDOUT)
+      @logger.formatter = proc { |severity, datetime, progname, msg| 
+        "[#{datetime}, #{severity}] #{msg}\n"
+      }
+      @logger
+    end
+
+    def logger=(logger)
+      @logger = logger
+    end
+
+  end
+end

data/lib/boundy/bound.rb

@@ -0,0 +1,65 @@
+require 'boundy/bound'
+require 'boundy/bound/infinite'
+require 'boundy/comparators'
+
+#require 'manacle/proxy'
+
+module Boundy
+  class Bound
+    def initialize(datum)
+      if datum.class <= self.class || datum.class < Boundy::Bound::Infinite
+        raise "Datum is a Bound already!"
+      end
+
+      if datum.nil?
+        raise "Datum passed is nil!"
+      end
+      @datum = datum
+    end
+
+    def after?(subject)
+      Comparators.comparator(self, subject).after?
+    end
+
+    def before?(subject)
+      Comparators.comparator(self, subject).before?
+    end
+
+    def within?(subject)
+      Comparators.comparator(self, subject).within?
+    end
+
+    def finite?
+      true
+    end
+
+    def infinite?
+      false
+    end
+
+    def inspect
+      "#<#{self.class.name} bounded at #{@datum.inspect}>"
+    end
+
+    def comparator
+      Boundy::Bound::Comparator
+    end
+
+    attr_reader :datum
+
+    include Comparable
+
+    def <=>(other)
+      case other
+      when Boundy::Bound::Infinite::Above
+        (other <=> self) * -1
+      when Boundy::Bound::Infinite::Below
+        (other <=> self) * -1
+      when Boundy::Bound
+        datum <=> other.datum
+      else
+        raise "Can not compare a Bound to a #{other.class}"
+      end
+    end
+  end
+end

data/lib/boundy/bound/comparator.rb

@@ -0,0 +1,67 @@
+require 'boundy/bound'
+require 'boundy/bound/infinite' 
+
+module Boundy
+  class Bound
+    class Comparator
+      def initialize(a, b)
+        @a = a
+        @b = b
+      end
+
+      Bound = Boundy::Bound
+
+      COMPARISONS = {
+        Bound::Infinite::Above => {
+          Bound::Infinite::Above => :equal,
+          Bound::Infinite::Below => :left,
+          Bound => :left
+        },
+        Bound::Infinite::Below => {
+          Bound::Infinite::Above => :right,
+          Bound::Infinite::Below => :equal,
+          Bound => :right
+        },
+        Bound => {
+          Bound::Infinite::Above => :right,
+          Bound::Infinite::Below => :left 
+        }
+      }
+
+      def before?
+        compare == :left 
+      end
+
+      def after?
+        compare == :right
+      end
+
+      def within?
+        compare == :equal
+      end
+
+      def compare
+        result = nil
+        if COMPARISONS.has_key?(@a.class)
+          part_comp = COMPARISONS[@a.class]
+          if part_comp.has_key?(@b.class)
+            result = part_comp[@b.class]
+          end
+        end
+
+        map = {
+          -1 => :right,
+          0 => :equal,
+          1 => :left
+        }
+
+        if result.nil?
+          map[@a.datum <=> @b.datum]
+        else
+          result
+        end
+
+      end
+    end
+  end
+end

data/lib/boundy/bound/constrainer.rb

@@ -0,0 +1,29 @@
+require 'boundy/bound/comparator'
+
+module Boundy
+  class Bound
+    class Constrainer
+      def initialize(a, b)
+        @a = a
+        @b = b
+        @comparator = Boundy::Bound::Comparator.new(a,b)
+      end
+
+      def max
+        if @comparator.compare == :left
+          @a
+        else
+          @b
+        end
+      end
+
+      def min
+        if @comparator.compare == :right
+          @a
+        else
+          @b
+        end
+      end
+    end
+  end
+end

data/lib/boundy/bound/infinite.rb

@@ -0,0 +1,46 @@
+module Boundy
+  # An Anterior domain date has a beginning, but no end -- hence, is
+  # anterior-domain.
+  class Bound
+    class Infinite
+      def after?(date_range)
+        false
+      end
+
+      def before?(date_range)
+        false
+      end
+
+      def within?(date_range)
+        true
+      end
+
+      def in_time_zone(tz)
+        self
+      end
+
+      def to_midnight
+        self
+      end
+
+      def date
+        nil
+      end
+
+      def finite?
+        false
+      end
+
+      def infinite?
+        true
+      end
+
+      def <=>(other)
+        raise ""
+      end
+    end
+  end
+end
+
+require 'boundy/bound/infinite/above'
+require 'boundy/bound/infinite/below'

data/lib/boundy/bound/infinite/above.rb

@@ -0,0 +1,12 @@
+module Boundy
+  class Bound
+    class Infinite
+      class Above < Infinite
+        include Comparable
+        def <=>(other)
+          1
+        end
+      end
+    end
+  end
+end

data/lib/boundy/bound/infinite/below.rb

@@ -0,0 +1,13 @@
+module Boundy
+  class Bound
+    class Infinite
+      class Below < Infinite
+        include Comparable
+        def <=>(other)
+          -1 
+        end
+      end
+    end
+  end
+end
+

data/lib/boundy/comparator.rb

@@ -0,0 +1,19 @@
+require 'boundy/comparators'
+
+module Boundy
+  module Comparator
+    def self.included(base)
+      types = if base.respond_to?(:type)
+                [base.type]
+              elsif base.respond_to?(:types)
+                base.types
+              else
+                []
+              end
+
+      types.each do |t|
+        Boundy::Comparators.add(t, base)
+      end
+    end
+  end
+end

data/lib/boundy/comparators.rb

@@ -0,0 +1,28 @@
+require 'set'
+
+require 'punchout'
+require 'punchout/matcher/class'
+
+module Boundy
+  module Comparators
+    extend Punchout::Punchable
+
+
+    def self.add(type, comparator)
+      matchable = Punchout::Matcher::Klass.new(type).punches(comparator)
+      puncher.add(matchable)
+    end
+
+    def self.comparator(datum,subject)
+      comparator = if subject.respond_to?(:comparator)
+                     subject.comparator
+                   else
+                     puncher.punch(subject.class)
+                   end
+
+      comparator.new(datum, subject)
+    rescue
+      raise "I can't compare myself to a #{subject.class}: #{subject.inspect}"
+    end
+  end
+end

data/lib/boundy/domain.rb

@@ -0,0 +1,115 @@
+require 'boundy/bound'
+
+require 'boundy/domain/comparator'
+require 'boundy/domain/constrainer'
+require 'boundy/range/constrainer'
+
+module Boundy
+  module Domain
+    module Plugin
+      def self.included(base)
+        Domain.builder.add(base)
+        base.instance_eval do
+          include InstanceMethods
+          attr_reader :from
+          attr_reader :to
+        end
+      end
+    end
+
+    class Builder
+      def initialize
+        @klasses = {}
+      end
+
+      def add(domain_klass)
+        builder = domain_klass.builder
+
+        bound_types = builder[:bounds]
+        builder_method = builder[:builder]
+
+        @klasses[bound_types] = builder_method
+      end
+
+      def build(a,b)
+        builder = @klasses[{from: a.class, to: b.class}]
+
+        if builder.nil?
+          raise "Could not find class for #{a.class} and #{b.class}"
+        end
+
+        builder.call(a,b)
+      end
+    end
+
+
+    def self.builder
+      @builder ||= Builder.new
+    end
+
+
+    def self.translate(bound)
+      if bound.class <= Boundy::Bound or bound.class < Boundy::Bound::Infinite
+        bound
+      else
+        Boundy::Bound.new(bound)
+      end
+    end
+
+    def self.new(b,e=nil)
+      if b.class <= Boundy::Domain::Plugin 
+        b
+      else
+        b = translate(b)
+        e = translate(e)
+
+        built = builder.build(b,e)
+        unless built.class < Plugin
+          raise
+        end
+        built
+      end
+    end
+
+    module InstanceMethods
+
+      def within?(subject)
+        @from.within?(subject) || @from.after?(subject) and
+        @to.within?(subject) || @to.before?(subject)
+      end
+
+      def joinable?(subject)
+        strictly_earlier?(subject) || strictly_later?(subject)
+      end
+
+      def constrain_to(subject)
+        constrainer(subject).constrain
+      end
+
+      def constrainer(subject)
+        if subject.class == ::Range
+          Boundy::Range::Constrainer.new(self, subject)
+        elsif subject.class < Boundy::Domain::Plugin
+          Boundy::Domain::Constrainer.new(self, subject)
+        else
+          raise "I can't constrain myself against a #{subject.class}"
+        end
+      end
+
+      def comparator
+        Boundy::Domain::Comparator
+      end
+
+      def format(formatter)
+        if from.finite?
+        elsif to.finite?
+        end
+      end
+    end
+  end
+end
+
+
+require 'boundy/domain/anterior'
+require 'boundy/domain/finite'
+require 'boundy/domain/posterior'

data/lib/boundy/domain/anterior.rb

@@ -0,0 +1,45 @@
+require 'boundy/domain'
+require 'boundy/bound'
+require 'boundy/bound/infinite/above' 
+
+module Boundy
+  module Domain
+    # An Anterior domain datum has a beginning, but no end -- hence, is
+    # anterior-domain.
+    class Anterior 
+      def self.builder
+        {
+          bounds: {
+            from: Boundy::Bound, 
+            to: Boundy::Bound::Infinite::Above
+          },
+          builder: Proc.new {|b,e| self.new(b) }
+        }
+      end
+
+      include Domain::Plugin
+
+      def initialize(datum)
+        if datum.nil?
+          raise
+        end
+
+        @from = case datum
+                when Boundy::Bound
+                  datum
+                else
+                  Boundy::Bound.new(datum)
+                end
+        @to = Boundy::Bound::Infinite::Above.new
+      end
+
+      def cute
+        "[#{@from.datum}, infinity]"
+      end
+
+      def inspect
+        "#<#{self.class.name} bounded below by #{@from.inspect}>"
+      end
+    end
+  end
+end