activefacts 0.8.9 → 0.8.10

data/lib/activefacts/api/support.rb

@@ -1,65 +0,0 @@
-#
-#       ActiveFacts Runtime API.
-#       Various additions or patches to Ruby built-in classes, and some global support methods
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-
-class Symbol #:nodoc:
-  def to_proc
-    Proc.new{|*args| args.shift.__send__(self, *args)}
-  end
-end
-
-class String #:nodoc:
-  def camelcase(first=false, on='_\s')
-    if first
-      gsub(/(^|[#{on}]+)([A-Za-z])/){ $2.upcase }
-    else
-      gsub(/([#{on}]+)([A-Za-z])/){ $2.upcase }
-    end
-  end
-
-  def snakecase
-    gsub(/([a-z])([A-Z])/,'\1_\2').downcase
-  end
-
-  def camelwords
-    gsub(/-([a-zA-Z])/){ $1.upcase }.                 # Break and upcase on hyphenated words
-      gsub(/([a-z])([A-Z])/,'\1_\2').
-      split(/[_\s]+/)
-  end
-end
-
-class Module #:nodoc:
-  def modspace
-    space = name[ 0...(name.rindex( '::' ) || 0)]
-    space == '' ? Object : eval(space)
-  end
-
-  def basename
-    name.gsub(/.*::/, '')
-  end
-end
-
-module ActiveFacts #:nodoc:
-  # If the args array ends with a hash, remove it.
-  # If the remaining args are fewer than the arg_names,
-  # extract values from the hash and append them to args.
-  # Return the new args array and the hash.
-  # In any case leave the original args unmodified.
-  def self.extract_hash_args(arg_names, args)
-    if Hash === args[-1]
-      arg_hash = args[-1]     # Don't pop args, leave it unmodified
-      args = args[0..-2]
-      arg_hash = arg_hash.clone if (args.size < arg_names.size)
-      while args.size < arg_names.size
-        args << arg_hash[n = arg_names[args.size]]
-        arg_hash.delete(n)
-      end
-    else
-      arg_hash = {}
-    end
-    return args, arg_hash
-  end
-end

data/lib/activefacts/api/value.rb

@@ -1,135 +0,0 @@
-#
-#       ActiveFacts Runtime API
-#       Value module (mixins for ValueType classes and instances)
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-# The methods of this module are added to Value type classes.
-#
-module ActiveFacts
-  module API
-
-    # All Value instances include the methods defined here
-    module Value
-      include Instance
-
-      # Value instance methods:
-      def initialize(*args) #:nodoc:
-        args[0] = args[0].__getobj__ if RoleProxy === args[0]
-        super(args)
-      end
-
-      # verbalise this Value
-      def verbalise(role_name = nil)
-        "#{role_name || self.class.basename} '#{to_s}'"
-      end
-
-      # A value is its own key
-      def identifying_role_values #:nodoc:
-        self
-      end
-
-      # All ValueType classes include the methods defined here
-      module ClassMethods
-        include Instance::ClassMethods
-
-        def initialise_value_type *args, &block #:nodoc:
-          # REVISIT: args could be a hash, with keys :length, :scale, :unit, :allow
-          #raise "value_type args unexpected" if args.size > 0
-        end
-
-        class_eval do
-          define_method :length do |*args|
-            @length = args[0] if args.length > 0
-            @length
-          end
-        end
-
-        class_eval do
-          define_method :scale do |*args|
-            @scale = args[0] if args.length > 0
-            @scale
-          end
-        end
-
-        class_eval do
-          define_method :restrict do |*value_ranges|
-            @value_ranges = *value_ranges
-          end
-        end
-
-        # verbalise this ValueType
-        def verbalise
-          # REVISIT: Add length and scale here, if set
-          # REVISIT: Set vocabulary name of superclass if not same as this
-          "#{basename} = #{superclass.basename}();"
-        end
-
-        def identifying_role_values(*args)  #:nodoc:
-          # If the single arg is the correct class or a subclass, use it directly
-          #puts "#{basename}.identifying_role_values#{args.inspect}"
-          if (args.size == 1 and (arg = args[0]).is_a?(self.class))   # No secondary supertypes allowed for value types
-            arg = arg.__getobj__ if RoleProxy === arg
-            return arg
-          end
-          new(*args)
-        end
-
-        def assert_instance(constellation, args)  #:nodoc:
-          # Build the key for this instance from the args
-          # The key of an instance is the value or array of keys of the identifying values.
-          # The key values aren't necessarily present in the constellation, even after this.
-          key = identifying_role_values(*args)
-          #puts "#{klass} key is #{key.inspect}"
-
-          # Find and return an existing instance matching this key
-          instances = constellation.instances[self]   # All instances of this class in this constellation
-          instance = instances[key]
-          # DEBUG: puts "assert #{self.basename} #{key.inspect} #{instance ? "exists" : "new"}"
-          return instance, key if instance      # A matching instance of this class
-
-          instance = new(*args)
-
-          instance.constellation = constellation
-          return *index_instance(instance)
-        end
-
-        def index_instance(instance, key = nil) #:nodoc:
-          instances = instance.constellation.instances[self]
-          key = instance.identifying_role_values
-          instances[key] = instance
-          # DEBUG: puts "indexing value #{basename} using #{key.inspect} in #{constellation.object_id}"
-
-          # Index the instance for each supertype:
-          supertypes.each do |supertype|
-            supertype.index_instance(instance, key)
-          end
-
-          return instance, key
-        end
-
-        def inherited(other)  #:nodoc:
-          #puts "REVISIT: ValueType #{self} < #{self.superclass} was inherited by #{other}; not implemented" #+"from #{caller*"\n\t"}"
-          # Copy the type parameters here, etc?
-          other.send :realise_supertypes, self
-          vocabulary.__add_concept(other)
-          super
-        end
-      end
-
-      def self.included other #:nodoc:
-        other.send :extend, ClassMethods
-
-        #puts "ValueType included in #{other.basename} from #{caller*"\n\t"}"
-
-        # Register ourselves with the parent module, which has become a Vocabulary:
-        vocabulary = other.modspace
-        # puts "ValueType.included(#{other.inspect})"
-        unless vocabulary.respond_to? :concept  # Extend module with Vocabulary if necessary
-          vocabulary.send :extend, Vocabulary
-        end
-        vocabulary.__add_concept(other)
-      end
-    end
-  end
-end

data/lib/activefacts/api/vocabulary.rb

@@ -1,82 +0,0 @@
-#
-#       ActiveFacts Runtime API
-#       Vocabulary module (mixin for any Module that contains classes having Concept mixed in)
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-# The methods of this module are extended into any module that contains
-# a Concept class (Entity type or Value type).
-#
-module ActiveFacts
-  module API
-    # Vocabulary is a mixin that adds methods to any Module which has any Concept classes (ValueType or EntityType).
-    # A Vocabulary knows all the Concept classes including forward-referenced ones,
-    # and can resolve the forward references when the class is finally defined.
-    # Construction of a Constellation requires a Vocabuary as argument.
-    module Vocabulary
-      # With a parameter, look up a concept class by name.
-      # Without, return the hash (keyed by the class' basename) of all concepts in this vocabulary
-      def concept(name = nil)
-        @concept ||= {}
-        return @concept unless name
-
-        return name if name.is_a? Class
-
-        # puts "Looking up concept #{name} in #{self.name}"
-        camel = name.to_s.camelcase(true)
-        if (c = @concept[camel])
-          __bind(camel)
-          return c
-        end
-        return (const_get("#{name}::#{camel}") rescue nil)
-      end
-
-      # Create a new constellation over this vocabulary
-      def constellation
-        Constellation.new(self)
-      end
-
-      def populate &b
-        constellation.populate &b
-      end
-
-      def verbalise
-        "Vocabulary #{name}:\n\t" +
-          @concept.keys.sort.map{|concept|
-              c = @concept[concept]
-              __bind(c.basename)
-              c.verbalise + "\n\t\t// Roles played: " + c.roles.verbalise
-            }*"\n\t"
-      end
-
-      def __add_concept(klass)  #:nodoc:
-        name = klass.basename
-        __bind(name)
-        # puts "Adding concept #{name} to #{self.name}"
-        @concept ||= {}
-        @concept[klass.basename] = klass
-      end
-
-      def __delay(concept_name, args, &block) #:nodoc:
-        # puts "Arranging for delayed binding on #{concept_name.inspect}"
-        @delayed ||= Hash.new { |h,k| h[k] = [] }
-        @delayed[concept_name] << [args, block]
-      end
-
-      # __bind raises an error if the named class doesn't exist yet.
-      def __bind(concept_name)  #:nodoc:
-        concept = const_get(concept_name)
-        # puts "#{name}.__bind #{concept_name} -> #{concept.name}" if concept
-        if (@delayed && @delayed.include?(concept_name))
-          # $stderr.puts "#{concept_name} was delayed, binding now"
-          d = @delayed[concept_name]
-          d.each{|(a,b)|
-              b.call(concept, *a)
-            }
-          @delayed.delete(concept_name)
-        end
-      end
-
-    end
-  end
-end

data/spec/api/autocounter.rb

@@ -1,82 +0,0 @@
-#
-# ActiveFacts tests: Value instances in the Runtime API
-# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
-#
-describe "AutoCounter Value Type instances" do
-  before :each do
-    Object.send :remove_const, :Mod if Object.const_defined?("Mod")
-    module Mod
-      class ThingId < AutoCounter
-        value_type
-      end
-      class Thing
-        identified_by :thing_id
-        has_one :thing_id
-      end
-      class Ordinal < Int
-        value_type
-      end
-      class ThingFacet
-        identified_by :thing, :ordinal
-        has_one :thing
-        has_one :ordinal
-      end
-    end
-    @constellation = ActiveFacts::API::Constellation.new(Mod)
-    @thing = Mod::Thing.new(:new)
-    @thing_id = Mod::ThingId.new
-  end
-
-  it "should respond to verbalise" do
-    @thing_id.respond_to?(:verbalise).should be_true
-  end
-
-  it "should verbalise correctly" do
-    @thing_id.verbalise.should =~ /ThingId 'new_[0-9]+'/
-  end
-
-  it "should respond to constellation" do
-    @thing_id.respond_to?(:constellation).should be_true
-  end
-
-  it "should respond to its roles" do
-    @thing_id.respond_to?(:all_thing).should be_true
-  end
-
-  it "should allow prevent invalid role assignment" do
-    lambda {
-        @thing.thing_id = "foo"
-      }.should raise_error
-  end
-
-  it "should not allow its identifying roles to be assigned" do
-    lambda {
-        @thing.thing_id = @thing_id
-      }.should raise_error
-  end
-
-  it "should allow an existing counter to be re-used" do
-    @new_thing = Mod::Thing.new(@thing_id)
-    @new_thing.thing_id.should == @thing_id
-  end
-
-  it "should return the ValueType in response to .class()" do
-    @thing_id.class.vocabulary.should == Mod
-  end
-
-  it "should not allow a counter to be cloned" do
-    lambda {
-      @thing_id.clone
-    }.should raise_error
-  end
-
-  it "should allow an existing counter-identified object to be re-used" do
-    thing = @constellation.Thing(:new)
-    facets = []
-    facets << @constellation.ThingFacet(thing, 0)
-    facets << @constellation.ThingFacet(thing, 1)
-    facets[0].thing.object_id.should == facets[1].thing.object_id
-    facets[0].thing.thing_id.object_id.should == facets[1].thing.thing_id.object_id
-  end
-
-end

data/spec/api/constellation.rb

@@ -1,130 +0,0 @@
-#
-# ActiveFacts tests: Constellation instances in the Runtime API
-# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
-#
-require "ruby-debug"
-
-require 'activefacts/api'
-
-describe "A Constellation instance" do
-  before :each do
-    Object.send :remove_const, :Mod if Object.const_defined?("Mod")
-    module Mod
-      @base_types = [
-          Int, Real, AutoCounter, String, Date, DateTime
-        ]
-
-      # Create a value type and a subtype of that value type for each base type:
-      @base_types.each do |base_type|
-        eval %Q{
-          class #{base_type.name}Value < #{base_type.name}
-            value_type
-          end
-
-          class #{base_type.name}SubValue < #{base_type.name}Value
-            # Note no new "value_type" is required here, it comes through inheritance
-          end
-        }
-      end
-
-      class Name < StringValue
-        value_type
-        #has_one :attr, Name
-      end
-
-      class LegalEntity
-        identified_by :name
-        has_one :name
-      end
-
-      class SurrogateId
-        identified_by :auto_counter_value
-        has_one :auto_counter_value
-      end
-
-      class Company < LegalEntity
-        supertypes SurrogateId
-      end
-
-      class Person < LegalEntity
-        identified_by :name, :family_name     # REVISIT: want a way to role_alias :name, :given_name
-        supertypes SurrogateId
-
-        has_one :family_name, :class => Name
-      end
-    end
-    @constellation = ActiveFacts::API::Constellation.new(Mod)
-  end
-
-  it "should support fetching its vocabulary" do
-    @constellation.vocabulary.should == Mod
-  end
-
-#  it "should support fetching its query" do
-#    pending
-#    @constellation.query.should == Mod
-#  end
-
-  it "should support methods to construct instances of any concept" do
-    name = foo = acme = fred_fly = nil
-    lambda {
-        name = @constellation.Name("foo")
-        foo = @constellation.LegalEntity("foo")
-        acme = @constellation.Company("Acme, Inc")
-        fred_fly = @constellation.Person("fred", "fly")
-      }.should_not raise_error
-    name.class.should == Mod::Name
-    name.constellation.should == @constellation
-    foo.class.should == Mod::LegalEntity
-    foo.constellation.should == @constellation
-    acme.class.should == Mod::Company
-    acme.constellation.should == @constellation
-    fred_fly.class.should == Mod::Person
-    fred_fly.constellation.should == @constellation
-  end
-
-  it "should re-use instances constructed the same way" do
-    name1 = @constellation.Name("foo")
-    foo1 = @constellation.LegalEntity("foo")
-    acme1 = @constellation.Company("Acme, Inc")
-    fred_fly1 = @constellation.Person("fred", "fly")
-
-    name2 = @constellation.Name("foo")
-    foo2 = @constellation.LegalEntity("foo")
-    acme2 = @constellation.Company("Acme, Inc")
-    fred_fly2 = @constellation.Person("fred", "fly")
-
-    name1.object_id.should == name2.object_id
-    foo1.object_id.should == foo2.object_id
-    acme1.object_id.should == acme2.object_id
-    fred_fly1.object_id.should == fred_fly2.object_id
-  end
-
-  it "should index value instances, including by its superclasses" do
-    baz = @constellation.Name("baz")
-    @constellation.Name.keys.sort.should == ["baz"]
-
-    @constellation.StringValue.keys.sort.should == ["baz"]
-  end
-
-  it "should index entity instances, including by its superclass and secondary supertypes" do
-    name = "Acme, Inc"
-    fred = "Fred"
-    fly = "Fly"
-    acme = @constellation.Company name, :auto_counter_value => :new
-    fred_fly = @constellation.Person fred, fly, :auto_counter_value => :new
-
-    # REVISIT: This should be illegal:
-    #fred_fly.auto_counter_value = :new
-
-    @constellation.Person.keys.sort.should == [[fred, fly]]
-    @constellation.Company.keys.sort.should == [[name]]
-
-    @constellation.LegalEntity.keys.sort.should be_include([name])
-    @constellation.LegalEntity.keys.sort.should be_include([fred])
-
-    @constellation.SurrogateId.values.should be_include(acme)
-    @constellation.SurrogateId.values.should be_include(fred_fly)
-  end
-
-end