activefacts 0.8.9 → 0.8.10

data/lib/activefacts/api/numeric.rb

@@ -1,167 +0,0 @@
-#
-#       ActiveFacts Runtime API
-#       Numeric and Date delegates and hacks to handle immediate types.
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-# These delegates are required because Integer & Float don't support new,
-# and can't be sensibly subclassed. Just delegate to an instance var.
-# Date and DateTime don't have a sensible new() method, so we monkey-patch one here.
-#
-require 'delegate'
-require 'date'
-
-# It's not possible to subclass Integer, so instead we delegate to it.
-class Int < SimpleDelegator
-  def initialize(i = nil)               #:nodoc:
-    __setobj__(Integer(i))
-  end
-
-  def to_s                              #:nodoc:
-    __getobj__.to_s
-  end
-
-  def hash                              #:nodoc:
-    __getobj__.hash ^ self.class.hash
-  end
-
-  def eql?(o)                           #:nodoc:
-    self.class == o.class and __getobj__.eql?(Integer(o))
-  end
-
-  def ==(o)                             #:nodoc:
-    __getobj__.==(o)
-  end
-
-  def inspect
-    "#{self.class.basename}:#{__getobj__.inspect}"
-  end
-end
-
-# It's not possible to subclass Float, so instead we delegate to it.
-class Real < SimpleDelegator
-  def initialize(r = nil)                               #:nodoc:
-    __setobj__(Float(r))
-  end
-
-  def hash                              #:nodoc:
-    __getobj__.hash ^ self.class.hash
-  end
-
-  def to_s                              #:nodoc:
-    __getobj__.to_s
-  end
-
-  def eql?(o)                           #:nodoc:
-    self.class == o.class and __getobj__.eql?(Float(o))
-  end
-
-  def ==(o)                             #:nodoc:
-    __getobj__.==(o)
-  end
-
-  def inspect                           #:nodoc:
-    "#{self.class.basename}:#{__getobj__.inspect}"
-  end
-end
-
-# A Date can be constructed from any Date subclass, not just using the normal date constructors.
-class ::Date
-  class << self; alias_method :old_new, :new end
-  # Date.new cannot normally be called passing a Date as the parameter. This allows that.
-  def self.new(*a, &b)
-    #puts "Constructing date with #{a.inspect} from #{caller*"\n\t"}"
-    if (a.size == 1 && a[0].is_a?(Date))
-      a = a[0]
-      civil(a.year, a.month, a.day, a.start)
-    elsif (a.size == 1 && a[0].is_a?(String))
-      parse(a[0])
-    else
-      civil(*a, &b)
-    end
-  end
-end
-
-# A DateTime can be constructed from any Date or DateTime subclass
-class ::DateTime
-  class << self; alias_method :old_new, :new end
-  # DateTime.new cannot normally be called passing a Date or DateTime as the parameter. This allows that.
-  def self.new(*a, &b)
-    #puts "Constructing DateTime with #{a.inspect} from #{caller*"\n\t"}"
-    if (a.size == 1)
-      a = a[0]
-      if (DateTime === a)
-        civil(a.year, a.month, a.day, a.hour, a.min, a.sec, a.start)
-      elsif (Date === a)
-        civil(a.year, a.month, a.day, a.start)
-      else
-        civil(*a, &b)
-      end
-    else
-      civil(*a, &b)
-    end
-  end
-end
-
-# The AutoCounter class is an integer, but only after the value
-# has been established in the database.
-# Construct it with the value :new to get an uncommitted value.
-# You can use this new instance as a value of any role of this type, including to identify an entity instance.
-# The assigned value will be filled out everywhere it needs to be, upon save.
-class AutoCounter
-  def initialize(i = :new)
-    raise "AutoCounter #{self.class} may not be #{i.inspect}" unless i == :new or Integer === i
-    # puts "new AutoCounter #{self.class} from\n\t#{caller.select{|s| s !~ %r{rspec}}*"\n\t"}"
-    @value = i == :new ? nil : i
-  end
-
-  # Assign a definite value to an AutoCounter; this may only be done once
-  def assign(i)
-    raise ArgumentError if @value
-    @value = i.to_i
-  end
-
-  # Ask whether a definite value has been assigned
-  def defined?
-    !@value.nil?
-  end
-
-  def to_s
-    if self.defined?
-      @value.to_s 
-    else
-      "new_#{object_id}"
-    end
-  end
-
-  # An AutoCounter may only be used in numeric expressions after a definite value has been assigned
-  def self.coerce(i)
-    raise ArgumentError unless @value
-    [ i.to_i, @value ]
-  end
-
-  def inspect
-    "\#<AutoCounter "+to_s+">"
-  end
-
-  def hash                              #:nodoc:
-    to_s.hash ^ self.class.hash
-  end
-
-  def eql?(o)                           #:nodoc:
-    self.class == o.class and to_s.eql?(o.to_s)
-  end
-
-  def self.inherited(other)             #:nodoc:
-    def other.identifying_role_values(*args)
-      return nil if args == [:new]  # A new object has no identifying_role_values
-      return new(*args)
-    end
-    super
-  end
-
-private
-  def clone
-    raise "Not allowed to clone AutoCounters"
-  end
-end

data/lib/activefacts/api/role.rb

@@ -1,80 +0,0 @@
-#
-#       ActiveFacts API
-#       Role class.
-#       Each accessor method created on an instance corresponds to a Role object in the instance's class.
-#       Binary fact types construct a Role at each end.
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-module ActiveFacts
-  module API
-
-    # A Role represents the relationship of one object to another (or to a boolean condition).
-    # Relationships (or binary fact types) have a Role at each end; one is declared using _has_one_
-    # or _one_to_one_, and the other is created on the counterpart class. Each Concept class maintains
-    # an array of the roles it plays.
-    class Role
-      attr_accessor :owner            # The Concept to which this role belongs
-      attr_accessor :name             # The name of the role (a Symbol)
-      attr_accessor :counterpart_concept  # A Concept Class (may be temporarily a Symbol before the class is defined)
-      attr_accessor :counterpart      # All roles except unaries have a binary counterpart
-      attr_accessor :unique           # Is this role played by at most one instance, or more?
-      attr_accessor :mandatory        # In a valid fact population, is this role required to be played?
-      attr_accessor :value_constraint  # Counterpart Instances playing this role must meet this constraint
-      attr_reader :is_identifying     # Is this an identifying role for owner?
-
-      def initialize(owner, counterpart_concept, counterpart, name, mandatory = false, unique = true)
-        @owner = owner
-        @counterpart_concept = counterpart_concept
-        @counterpart = counterpart
-        @name = name
-        @mandatory = mandatory
-        @unique = unique
-        @is_identifying = @owner.is_entity_type && @owner.identifying_role_names.include?(@name)
-      end
-
-      # Is this role a unary (created by maybe)? If so, it has no counterpart
-      def unary?
-        # N.B. A role with a forward reference looks unary until it is resolved.
-        counterpart == nil
-      end
-
-      def resolve_counterpart(vocabulary)  #:nodoc:
-        return @counterpart_concept if @counterpart_concept.is_a?(Class)   # Done already
-        klass = vocabulary.concept(@counterpart_concept)   # Trigger the binding
-        raise "Cannot resolve role counterpart_concept #{@counterpart_concept.inspect} for role #{name} in vocabulary #{vocabulary.basename}; still forward-declared?" unless klass
-        @counterpart_concept = klass                       # Memoize a successful result
-      end
-
-      def adapt(constellation, value) #:nodoc:
-        # If the value is a compatible class, use it (if in another constellation, clone it),
-        # else create a compatible object using the value as constructor parameters.
-        if value.is_a?(@counterpart_concept)  # REVISIT: may be a non-primary subtype of counterpart_concept
-          value = value.__getobj__ if RoleProxy === value
-          # Check that the value is in a compatible constellation, clone if not:
-          if constellation && (vc = value.constellation) && vc != constellation
-            value = value.clone   # REVISIT: There's sure to be things we should reset/clone here, like non-identifying roles
-          end
-          value.constellation = constellation if constellation
-        else
-          value = [value] unless Array === value
-          raise "No parameters were provided to identify an #{@counterpart_concept.basename} instance" if value == []
-          if constellation
-            value = constellation.send(@counterpart_concept.basename.to_sym, *value)
-          else
-            value = @counterpart_concept.new(*value)
-          end
-        end
-        value
-      end
-    end
-
-    # Every Concept has a Role collection
-    # REVISIT: You can enumerate the concept's own roles, or inherited roles as well.
-    class RoleCollection < Hash #:nodoc:
-      def verbalise
-        keys.sort_by(&:to_s).inspect
-      end
-    end
-  end
-end

data/lib/activefacts/api/role_proxy.rb

@@ -1,70 +0,0 @@
-#
-#       ActiveFacts Runtime API
-#       RoleProxy class, still somewhat experimental
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-require 'delegate'
-
-module ActiveFacts
-  module API
-    #
-    # When you use the accessor method created by has_one, one_to_one, or maybe, you get a RoleProxy for the actual value.
-    # This behaves almost exactly as the value, but it knows through which role you fetched it.
-    # That will allow it to verbalise itself using the correct reading for that role.
-    #
-    # Don't use "SomeClass === role_value" to test the type, use "role_value.is_a?(SomeClass)" instead.
-    #
-    # In future, retrieving a value by indexing into a RoleValues array will do the same thing.
-    #
-    class RoleProxy < SimpleDelegator
-      def initialize(role, o = nil)     #:nodoc:
-        @role = role                    # REVISIT: Use this to implement verbalise()
-        __setobj__(o)
-      end
-
-      def method_missing(m, *a, &b)     #:nodoc:
-        begin
-          super                         # Delegate first
-        rescue NoMethodError => e
-          __getobj__.method_missing(m, *a, &b)
-        rescue => e
-          raise
-        end
-      end
-
-      def class                         #:nodoc:
-        __getobj__.class
-      end
-
-      def is_a? klass                   #:nodoc:
-        __getobj__.is_a? klass
-      end
-
-      def to_s                          #:nodoc:
-        __getobj__.to_s
-      end
-
-      def object_id                     #:nodoc:
-        __getobj__.object_id
-      end
-
-      # REVISIT: Should Proxies hash and eql? the same as their wards?
-      def hash                          #:nodoc:
-        __getobj__.hash ^ self.class.hash
-      end
-
-      def eql?(o)                       #:nodoc:
-        self.class == o.class and __getobj__.eql?(o)
-      end
-
-      def ==(o)                         #:nodoc:
-        __getobj__.==(o)
-      end
-
-      def inspect                       #:nodoc:
-        "Proxy:#{__getobj__.inspect}"
-      end
-    end
-  end
-end

data/lib/activefacts/api/role_values.rb

@@ -1,117 +0,0 @@
-#
-#       ActiveFacts Runtime API
-#       RoleValues, manages the set of instances involved in a many_to_one relationship.
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-# There are two implementations here, one using an array and one using a hash.
-# The hash one has problems with keys being changed during object deletion, so
-# cannot be used yet; a fix is upcoming and will improve performance of large sets.
-#
-module ActiveFacts
-  module API
-
-    class RoleValues  #:nodoc:
-      include Enumerable
-
-#=begin
-      def initialize
-        @a = []
-      end
-
-      def each &b
-        # REVISIT: Provide a configuration variable to enable this heckling during testing:
-        #@a.sort_by{rand}.each &b
-        @a.each &b
-      end
-
-      def size
-        @a.size
-      end
-
-      def empty?
-        @a.size == 0
-      end
-
-      def +(a)
-        @a.+(a.is_a?(RoleValues) ? Array(a) : a)
-      end
-
-      def -(a)
-        @a - a
-      end
-
-      def single
-        @a.size > 1 ? nil : @a[0]
-      end
-
-      def update(old, value)
-        @a.delete(old) if old
-        @a << value if value
-        raise "Adding RoleProxy to RoleValues collection" if value && RoleProxy === value
-      end
-
-      def verbalise
-        "["+@a.to_a.map{|e| e.verbalise}*", "+"]"
-      end
-#=end
-
-=begin
-      def initialize
-        @h = {}
-      end
-
-      def each &b
-        @h.keys.each &b
-      end
-
-      def size
-        @h.size
-      end
-
-      def empty?
-        @h.size == 0
-      end
-
-      def +(a)
-        @h.keys.+(a.is_a?(RoleValues) ? Array(a) : a)
-      end
-
-      def -(a)
-        @h.keys - a
-      end
-
-      def single
-        @h.size > 1 ? nil : @h.keys[0]
-      end
-
-      def update(old, value)
-        if old
-          unless @h.delete(old)
-            @h.each { |k, v|
-              next if k != old
-              puts "#{@h.object_id}: Didn't delete #{k.verbalise} (hash=#{k.hash}) matching #{old.verbalise} (hash=#{old.hash})"
-              puts "They are #{k.eql?(old) ? "" : "not "}eql?"
-              found = @h[k]
-              puts "found #{found.inspect}" if found
-              debugger
-              x = k.eql?(old)
-              y = old.eql?(k)
-              p y
-            }
-            raise "failed to delete #{old.verbalise}, have #{map{|e| e.verbalise}.inspect}"
-          end
-        end
-        puts "#{@h.object_id}: Adding #{value.inspect}" if value && (value.name == 'Meetingisboardmeeting' rescue false)
-        @h[value] = true if value
-      end
-
-      def verbalise
-        "["+@h.keys.map{|e| e.verbalise}*", "+"]"
-      end
-=end
-
-    end
-
-  end
-end

data/lib/activefacts/api/standard_types.rb

@@ -1,87 +0,0 @@
-#
-#       ActiveFacts Runtime API
-#       Standard types extensions.
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-# These extensions add ActiveFacts Concept and Instance behaviour into base Ruby value classes,
-# and allow any Class to become an Entity.
-#
-require 'date'
-
-module ActiveFacts
-  module API
-    # Adapter module to add value_type to all potential value classes
-    module ValueClass #:nodoc:
-      def value_type *args, &block #:nodoc:
-        include ActiveFacts::API::Value
-        # the included method adds the Value::ClassMethods
-        initialise_value_type(*args, &block)
-      end
-    end
-  end
-end
-
-require 'activefacts/api/numeric'
-
-# Add the methods that convert our classes into Concept types:
-
-ValueClasses = [String, Date, DateTime, Time, Int, Real, AutoCounter]
-ValueClasses.each{|c|
-    c.send :extend, ActiveFacts::API::ValueClass
-  }
-
-class TrueClass #:nodoc:
-  def verbalise(role_name = nil); role_name ? "#{role_name}: true" : "true"; end
-end
-
-class NilClass #:nodoc:
-  def verbalise; "nil"; end
-end
-
-class Class
-  # Make this Class into a Concept and if necessary its module into a Vocabulary.
-  # The parameters are the names (Symbols) of the identifying roles.
-  def identified_by *args
-    raise "#{basename} is not an entity type" if respond_to? :value_type  # Don't make a ValueType into an EntityType
-    include ActiveFacts::API::Entity
-    initialise_entity_type(*args)
-  end
-
-  def is_entity_type
-    respond_to?(:identifying_role_names)
-  end
-end
-
-require 'bigdecimal'
-class Decimal < BigDecimal #:nodoc:
-  extend ActiveFacts::API::ValueClass
-  # The problem here is you can't pass a BigDecimal to BigDecimal.new. Fix it.
-  def self.new(v)
-    if v.is_a?(BigDecimal)
-      super(v.to_s)
-    else
-      super
-    end
-  end
-end
-
-# These types are generated on conversion from NORMA's types:
-class Char < String #:nodoc:  # FixedLengthText
-end
-class Text < String #:nodoc:  # LargeLengthText
-end
-class Image < String #:nodoc: # PictureRawData
-end
-class SignedInteger < Int #:nodoc:
-end
-class UnsignedInteger < Int   #:nodoc:
-end
-class AutoTimeStamp < String  #:nodoc: AutoTimeStamp
-end
-class Blob < String           #:nodoc: VariableLengthRawData
-end
-unless Object.const_defined?("Money")
-  class Money < Decimal       #:nodoc:
-  end
-end