vidalia 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5a60b306129eebe17ace114e099a2002c8b270e2
+  data.tar.gz: 107470ee1e0d86ce65231c79c42be2e7000aeebd
+SHA512:
+  metadata.gz: 9eab8185fad11164351b752c94cfc32b93e13d3344f35e26962d11e1bedc39e464a63361fe0b2d79d2bee7383b13b861a712856dc7f5fb5ebdd22a139eaf7f67
+  data.tar.gz: 72981f0c4531399059f2b766e98cc1c6f240c63d29d012880c662f7d4cc0fcb3a0ea30b3b8f4d810084d2a9dc43300fb02a18d52153fcde70ef1977d85caf7d5

data/lib/vidalia/artifact.rb

@@ -0,0 +1,159 @@
+module Vidalia
+
+  class Artifact
+ 
+    attr_reader :name, :parent, :init_block
+
+    # Create an Artifact
+    #
+    # Initializes a Vidalia::Artifact using the data set in Vidalia::Artifact.define.  If such data
+    # does not exist, this routine will error out.  This ensures that all Artifacts have been
+    # predefined.
+    #
+    # *Options*
+    #
+    # Takes a hash as input where the current options are:
+    # +name+:: (required) specifies the name of the Interface
+    # +parent+:: (required) specifies the Vidalia::Identifier of the parent object
+    # +definition+:: (optional) specifies the Vidalia::Artifact contained by the artifact's definition
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    #
+    def initialize(opts = {},&block)
+      o = {
+        :name => nil,
+        :parent => nil,
+        :definition => nil
+      }.merge(opts)
+
+      Vidalia::checkvar(o[:name],String,self.class.ancestors,"name")
+      @name = o[:name]
+      @type = Vidalia::Artifact unless @type
+      @children = Hash.new
+
+      if o[:parent]
+        # Add myself as a child of my parent
+        Vidalia::checkvar(o[:parent],Vidalia::Artifact,self.class.ancestors,"parent")
+        @parent = o[:parent]
+        @parent.add_child(self)
+      else
+        # Just kidding.  I'm an orphan.  :(
+        @parent = nil
+      end
+
+      @source_artifact = o[:definition]
+
+      if @source_artifact
+        # If this is an instantiation of a definition
+
+        Vidalia::checkvar(@source_artifact,Vidalia::Artifact,self.class.ancestors,"definition")
+
+        # Copy the initialization block and run it if defined
+        @init_block = @source_artifact.init_block
+        if @init_block
+          block = @init_block
+          instance_eval(&block)
+        end
+      else
+        # If this is only a definition
+
+        # Store the initialization block
+        @init_block = block
+      end
+    end
+
+
+    # Copy an Artifact from another Artifact
+    #
+    # *Options*
+    #
+    # Takes one parameter:
+    # +source+:: specifies the name of the Interface to copy from
+    #
+    # *Example*
+    #
+    #   $$$ Example Needed $$$
+    #
+    def self.copy_from(source)
+      Vidalia::checkvar(source,Vidalia::Artifact,self.class.ancestors,"source")
+      @name = source.type
+      @type = source.type
+      @init_block = source.init_block
+      super
+    end
+
+  
+    # Add a child object to this Artifact
+    #
+    # *Options*
+    #
+    # This method takes one parameter:
+    # +object+:: specifies a Vidalia::Artifact object to be added as a child
+    #
+    # *Example*
+    #
+    #   # Note that both the "Blog API" and "Blog Post" Artifacts must be predefined
+    #   blog_api = Vidalia::Artifact.new("Blog API")
+    #   blog_post = Vidalia::Artifact.new("Blog Post")
+    #   blog_api.add_child(blog_post)
+    #
+    def add_child(object)
+      Vidalia::checkvar(object,Vidalia::Artifact,self.class.ancestors,"object")
+      @children[object.name] = object
+      object.set_parent(self)
+    end
+
+
+    # Get a child of this Artifact
+    #
+    # *Options*
+    #
+    # This method takes one parameter:
+    # +name+:: specifies the name of a child of this Artifact
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    #
+    def get_child(name)
+      Vidalia::checkvar(name,String,self.class.ancestors,"name")
+      @children[name]
+    end
+
+
+    # Get a the number of children of this Artifact
+    #
+    # *Options*
+    #
+    # This method takes no parameters.
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    #
+    def number_of_children
+      @children.size
+    end
+  
+    
+    # Set the parent of this Artifact
+    #
+    # *Options*
+    #
+    # This method takes one parameter:
+    # +parent+: specifies the parent object of this Artifact
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    #
+    def set_parent(parent)
+      @parent = parent
+    end
+  
+    
+  end
+
+end

data/lib/vidalia/element.rb

@@ -0,0 +1,413 @@
+module Vidalia
+
+  class Element < Artifact
+ 
+    attr_reader :name, :parent, :set_function, :get_function, :retrieve_function, :verify_function, :confirm_function, :update_function
+
+    # Define an Element
+    #
+    # This routine takes a Vidalia::ObjectDefinition and adds an Element
+    # definition to the associated Object.
+    #
+    # *Options*
+    #
+    # Takes a hash as input where the current options are:
+    # +name+:: specifies the name of the Element
+    # +parent+:: specifies the Object that the Element is associated with
+    #
+    # +block+:: specifies the block of code to be run when the Element is initialized
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    #
+    def self.define(opts = {}, &block)
+      Vidalia::ElementDefinition.new(opts,&block)
+    end
+
+
+    # Create an Element (inherited from Vidalia::Artifact)
+    #
+    # Initializes a Vidalia::Element using the data set in 
+    # Vidalia::Element.define.  If such data does not exist, this routine will 
+    # error out.  This ensures that all Elements have been predefined.
+    #
+    # *Options*
+    #
+    # Takes a hash as input where the current options are:
+    # +name+:: specifies the name of the Interface
+    # +parent+:: specifies the Vidalia::Identifier of the parent object
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    #
+    def initialize(opts = {})
+      o = {
+        :name => nil,
+        :parent => nil,
+        :definition => nil,
+      }.merge(opts)
+
+      @type = Vidalia::Element
+      super
+      if o[:definition]
+        my_def = o[:definition]
+        Vidalia::checkvar(my_def,Vidalia::Element,self.class.ancestors,"definition")
+        @get_function = my_def.get_function
+        @set_function = my_def.set_function
+        @retrieve_function = my_def.retrieve_function
+        @verify_function = my_def.verify_function
+        @confirm_function = my_def.confirm_function
+        @update_function = my_def.update_function
+        if @get_function
+          add_generic_retrieve() unless @retrieve_function
+          add_generic_verify() unless @verify_function
+          add_generic_confirm() unless @confirm_function
+          if @set_function
+            add_generic_update() unless @update_function
+          end
+        end
+      end
+    end
+
+
+    # Set the generic retrieve directive for this Element
+    #
+    # *Options*
+    #
+    # Takes no parameters.
+    #
+    # *Example*
+    #
+    #   $$$ Example Needed $$$
+    #
+    def add_generic_retrieve()
+      @retrieve_function = @get_function
+    end
+
+
+    # Set the generic verify directive for this Element
+    #
+    # *Options*
+    #
+    # Takes no parameters.
+    #
+    # *Example*
+    #
+    #   $$$ Example Needed $$$
+    #
+    def add_generic_verify()
+      add_verify { |value|
+        found_value = retrieve(value)
+        if value == found_value
+          Vidalia.log("Verified #{@name} to be \"#{value}\"")
+        else
+          raise "Expected #{@name} to be \"#{value}\", but found \"#{found_value}\" instead"
+        end
+        true
+      }
+    end
+
+
+    # Set the generic confirm directive for this Element
+    #
+    # *Options*
+    #
+    # Takes no parameters.
+    #
+    # *Example*
+    #
+    #   $$$ Example Needed $$$
+    #
+    def add_generic_confirm()
+      add_confirm { |value|
+        retval = false
+        found_value = retrieve(value)
+        if value == found_value
+          retval = true
+        end
+        retval
+      }
+    end
+
+
+    # Set the generic update directive for this Element
+    #
+    # *Options*
+    #
+    # Takes no parameters.
+    #
+    # *Example*
+    #
+    #   $$$ Example Needed $$$
+    #
+    def add_generic_update()
+      add_update { |value|
+        new_value = value
+        found_value = retrieve()
+        if new_value == found_value
+          capital_text = @name
+          capital_text[0] = capital_text[0].capitalize
+          Vidalia.log("#{capital_text} is already set to \"#{new_value}\"")
+        else
+          Vidalia.log("Entering #{@name}: \"#{new_value}\" (was \"#{found_value}\")")
+          set(new_value)
+        end
+      }
+    end
+
+
+    # Copy an Interface from another Interface (inherited from Vidalia::Artifact)
+    #
+    # *Options*
+    #
+    # Takes one parameter:
+    # +source+:: specifies the name of the Interface to copy from
+    #
+    # *Example*
+    #
+    #   $$$ Example Needed $$$
+    #
+    def self.copy_from(source)
+      super
+    end
+
+  
+    # Add a "get" function
+    #
+    # This function will be called to obtain the data element value from the
+    # Object.  A call to "get" really makes the most sense AFTER obtaining
+    # data from the database/API.
+    #
+    # *Options*
+    #
+    # Takes a block to be executed when "get" for this Element is invoked.
+    # The input block should take a hash as a parameter.
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    #
+    def add_get(&block)
+      @get_function = block
+    end
+
+
+    # Call the "get" function
+    #
+    # Call the pre-defined "get" function for this element.
+    #
+    # *Options*
+    #
+    # Takes a hash as input, with data as expected by the pre-defined "get" 
+    # block.
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    #
+    def get(inparams = {})
+      block = @get_function
+      instance_exec(inparams,&block)
+    end
+
+
+    # Add a "set" function
+    #
+    # This function will be called to set the element's value in the Object.
+    # Object.  A call to "set" really makes the most sense BEFORE making an
+    # alteration to the Object data via database/API call.
+    #
+    # *Options*
+    #
+    # Takes a block to be executed when "set" for this Element is invoked.
+    # The input block should take a hash as a parameter.
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    #
+    def add_set(&block)
+      @set_function = block
+    end
+
+
+    # Call the "set" function
+    #
+    # Call the pre-defined "set" function for this element.
+    #
+    # *Options*
+    #
+    # Takes a hash as input, with data as expected by the pre-defined "set" 
+    # block.
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    #
+    def set(inparams = {})
+      block = @set_function
+      instance_exec(inparams,&block)
+    end
+
+
+    # Add a "retrieve" function
+    #
+    # This function will be called to obtain the data element value from the
+    # Object.  A call to "retrieve" really makes the most sense AFTER obtaining
+    # data from the database/API.
+    #
+    # *Options*
+    #
+    # Takes a block to be executed when "retrieve" for this Element is invoked.
+    # The input block should take a hash as a parameter.
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    #
+    def add_retrieve(&block)
+      @retrieve_function = block
+    end
+
+
+    # Call the "retrieve" function
+    #
+    # Call the pre-defined "retrieve" function for this element.
+    #
+    # *Options*
+    #
+    # Takes a hash as input, with data as expected by the pre-defined "retrieve" 
+    # block.
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    #
+    def retrieve(inparams = {})
+      block = @retrieve_function
+      instance_exec(inparams,&block)
+    end
+
+
+    # Add a "verify" function
+    #
+    # This function will be called to obtain the data element value from the
+    # Object.  A call to "verify" really makes the most sense AFTER obtaining
+    # data from the database/API.
+    #
+    # *Options*
+    #
+    # Takes a block to be executed when "verify" for this Element is invoked.
+    # The input block should take a hash as a parameter.
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    #
+    def add_verify(&block)
+      @verify_function = block
+    end
+
+
+    # Call the "verify" function
+    #
+    # Call the pre-defined "verify" function for this element.
+    #
+    # *Options*
+    #
+    # Takes a hash as input, with data as expected by the pre-defined "verify" 
+    # block.
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    #
+    def verify(inparams = {})
+      block = @verify_function
+      instance_exec(inparams,&block)
+    end
+
+
+    # Add a "confirm" function
+    #
+    # This function will be called to obtain the data element value from the
+    # Object.  A call to "confirm" really makes the most sense AFTER obtaining
+    # data from the database/API.
+    #
+    # *Options*
+    #
+    # Takes a block to be executed when "confirm" for this Element is invoked.
+    # The input block should take a hash as a parameter.
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    #
+    def add_confirm(&block)
+      @confirm_function = block
+    end
+
+
+    # Call the "confirm" function
+    #
+    # Call the pre-defined "confirm" function for this element.
+    #
+    # *Options*
+    #
+    # Takes a hash as input, with data as expected by the pre-defined "confirm" 
+    # block.
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    #
+    def confirm(inparams = {})
+      block = @confirm_function
+      instance_exec(inparams,&block)
+    end
+
+
+    # Add a "update" function
+    #
+    # This function will be called to obtain the data element value from the
+    # Object.  A call to "update" really makes the most sense AFTER obtaining
+    # data from the database/API.
+    #
+    # *Options*
+    #
+    # Takes a block to be executed when "update" for this Element is invoked.
+    # The input block should take a hash as a parameter.
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    #
+    def add_update(&block)
+      @update_function = block
+    end
+
+
+    # Call the "update" function
+    #
+    # Call the pre-defined "update" function for this element.
+    #
+    # *Options*
+    #
+    # Takes a hash as input, with data as expected by the pre-defined "update" 
+    # block.
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    #
+    def update(inparams = {})
+      block = @update_function
+      instance_exec(inparams,&block)
+    end
+
+
+  end
+
+end

data/lib/vidalia/element_definition.rb

@@ -0,0 +1,179 @@
+module Vidalia
+
+  class ElementDefinition
+
+    attr_reader :name, :parent, :children, :element
+
+    # Create an Element Definition
+    #
+    # Under the covers, the ElementDefinition will create an associated
+    # Element definition.  Any instantiated Element under the parent Object
+    # will be copied from this master copy.
+    #
+    # *Options*
+    #
+    # Takes two parameters:
+    # Takes a hash as input where the current options are:
+    # +name+:: (required) specifies the name of the Element
+    # +parent+:: (required) specifies the name of the parent Object
+    # Takes a block to be executed at initialization time
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    #
+    def initialize(opts = {}, &block)
+      o = {
+        :name => nil,
+        :parent => nil
+      }.merge(opts)
+
+      Vidalia::checkvar(o[:name],String,self.class.ancestors,"name")
+      Vidalia::checkvar(o[:parent],Vidalia::ObjectDefinition,self.class.ancestors,"parent")
+
+      o[:parent] = o[:parent].object
+      @element = Vidalia::Element.new(o,&block)
+    end
+
+
+    # Add a "get" function for a Defined Element
+    #
+    # This function will be called to obtain the data element value from the
+    # Object.  A call to "get" really makes the most sense AFTER obtaining
+    # data from the database/API.
+    #
+    # *Options*
+    #
+    # Takes a block to be executed when "get" for this defined Element is 
+    # invoked.
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    #
+    def add_get(&block)
+      if block.arity > 1
+        raise "Vidalia::ElementDefinition.add_get block must take a single parameter"
+      end
+      @element.add_get &block
+    end
+
+
+    # Add a "set" function for a Defined Element
+    #
+    # This function will be called to set the element's value in the Object.
+    # Object.  A call to "set" really makes the most sense BEFORE making an
+    # alteration to the Object data via database/API call.
+    #
+    # *Options*
+    #
+    # Takes a block to be executed when "set" for this defined Element is 
+    # invoked.
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    #
+    def add_set(&block)
+      if block.arity > 1
+        raise "Vidalia::ElementDefinition.add_set block must take a single parameter"
+      end
+      @element.add_set &block
+    end
+
+
+    # Add a "retrieve" function for a Defined Element
+    #
+    # This function will be called to obtain the data element value from the
+    # Object.  A call to "retrieve" really makes the most sense AFTER obtaining
+    # data from the database/API.
+    #
+    # *Options*
+    #
+    # Takes a block to be executed when "retrieve" for this defined Element is 
+    # invoked.
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    #
+    def add_retrieve(&block)
+      if block.arity > 1
+        raise "Vidalia::ElementDefinition.add_retrieve block must take a single parameter"
+      end
+      @element.add_retrieve &block
+    end
+
+
+    # Add a "verify" function for a Defined Element
+    #
+    # This function will be called to obtain the data element value from the
+    # Object.  A call to "verify" really makes the most sense AFTER obtaining
+    # data from the database/API.
+    #
+    # *Options*
+    #
+    # Takes a block to be executed when "verify" for this defined Element is 
+    # invoked.
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    #
+    def add_verify(&block)
+      if block.arity > 1
+        raise "Vidalia::ElementDefinition.add_verify block must take a single parameter"
+      end
+      @element.add_verify &block
+    end
+
+
+    # Add a "confirm" function for a Defined Element
+    #
+    # This function will be called to obtain the data element value from the
+    # Object.  A call to "confirm" really makes the most sense AFTER obtaining
+    # data from the database/API.
+    #
+    # *Options*
+    #
+    # Takes a block to be executed when "confirm" for this defined Element is 
+    # invoked.
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    #
+    def add_confirm(&block)
+      if block.arity > 1
+        raise "Vidalia::ElementDefinition.add_confirm block must take a single parameter"
+      end
+      @element.add_confirm &block
+    end
+
+
+    # Add a "update" function for a Defined Element
+    #
+    # This function will be called to obtain the data element value from the
+    # Object.  A call to "update" really makes the most sense when updating 
+    # data AFTER obtaining data from the database/API.
+    #
+    # *Options*
+    #
+    # Takes a block to be executed when "update" for this defined Element is 
+    # invoked.
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    #
+    def add_update(&block)
+      if block.arity > 1
+        raise "Vidalia::ElementDefinition.add_update block must take a single parameter"
+      end
+      @element.add_update &block
+    end
+
+
+  end
+
+end

data/lib/vidalia/interface.rb

@@ -0,0 +1,106 @@
+module Vidalia
+
+  class Interface < Artifact
+
+    attr_reader :name, :interface
+
+    # Define an Interface
+    #
+    # This routine "stores" the defined Interface attributes in a
+    # Vidalia::InterfaceDefinition.  Any subsequent call to instantiate
+    # an Interface object will copy that object from the InterfaceDefinition.
+    #
+    # *Options*
+    #
+    # Takes a hash as input where the current options are:
+    # +name+:: (required) specifies the name of the interface
+    # +block+:: (optional) specifies a block of code to be run when the interface object is initialized
+    #
+    # *Example*
+    #
+    #   Vidalia::Interface.define(:name => "Blog API") {
+    #     @db_password = ENV['BLOG_DB_PASSWORD']
+    #     @db_userid = ENV['BLOG_DB_PASSWORD']
+    #     @db_ip = ENV['BLOG_DB_IP']
+    #     @db_port = ENV['BLOG_DB_PORT']
+    #   }
+    #
+    def self.define(opts = {}, &block)
+      Vidalia::InterfaceDefinition.new(opts,&block)
+    end
+
+
+    # Create an Interface (inherited from Vidalia::Artifact)
+    #
+    # Initializes a Vidalia::Interface using the data set in Vidalia::Interface.define.  If such data
+    # does not exist, this routine will error out.  This ensures that all Interfaces have been
+    # predefined.
+    #
+    # *Options*
+    #
+    # Takes a hash as input where the current options are:
+    # +name+:: specifies the name of the Interface
+    #
+    # *Example*
+    #
+    #   blog_api = Vidalia::Interface.new("Blog API")
+    #
+    def initialize(opts = {}, &block)
+      o = {
+        :name => nil,
+        :definition => nil
+      }.merge(opts)
+
+      @type = Vidalia::Interface 
+      super
+    end
+
+
+    # Retrieve a child Object of this Interface by name
+    #
+    # *Options*
+    #
+    # This method takes one parameter:
+    # +name+:: specifies the name of the child Object
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    #
+    def object(name)
+      Vidalia::checkvar(name,String,self.class.ancestors,"name")
+      child = get_child(name)
+      unless child
+        # Child does not yet exist.  Create it.
+        child = Vidalia::Object.new(
+          :name => name,
+          :parent => self,
+          :definition => @source_artifact.get_child(name)
+        )
+      end
+      child
+    end
+  
+    
+    # Get an Interface object by name
+    #
+    # *Options*
+    #
+    # This method takes one parameter:
+    # +name+:: (required) specifies the name of the Interface
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    #
+    def self.get(name)
+      return Vidalia::Interface.new(
+        :name => name,
+        :definition => Vidalia::InterfaceDefinition.find(name)
+      )
+    end
+
+
+  end
+
+end

data/lib/vidalia/interface_definition.rb

@@ -0,0 +1,69 @@
+module Vidalia
+
+  class InterfaceDefinition
+
+    @@interfaces = []
+    attr_reader :name, :parent, :interface
+
+    # Create an Interface Definition
+    #
+    # Under the covers, the InterfaceDefinition will create or find the
+    # associated Interface definition.  Any instantiated Interface will
+    # be copied from this master copy.
+    #
+    # *Options*
+    #
+    # Takes two parameters:
+    # Takes a hash as input where the current options are:
+    # +name+:: (required) specifies the name of the Interface
+    # Takes a block to be executed at initialization time
+    #
+    # *Example*
+    #
+    #   blog_api = Vidalia::InterfaceDefinition.new("Blog API") {
+    #     @db_password = ENV['BLOG_DB_PASSWORD']
+    #     @db_userid = ENV['BLOG_DB_PASSWORD']
+    #     @db_ip = ENV['BLOG_DB_IP']
+    #     @db_port = ENV['BLOG_DB_PORT']
+    #   }
+    #
+    def initialize(opts = {}, &block)
+      o = {
+        :name => nil
+      }.merge(opts)
+
+      Vidalia::checkvar(o[:name],String,self.class.ancestors,"name")
+
+      # It's OK to "define" an Interface that has already been defined
+      unless Vidalia::InterfaceDefinition.find(o[:name])
+        @interface = Vidalia::Interface.new(opts,&block)
+        @@interfaces << @interface
+      end
+    end
+
+
+    # Find an Interface by name
+    #
+    # *Options*
+    #
+    # Takes one parameter:
+    # +name+:: (required) specifies the name of the Interface
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    #
+    def self.find(name)
+      Vidalia::checkvar(name,String,self.class.ancestors,"name")
+      interface = nil
+      @@interfaces.each do |i|
+        if i.name == name
+          interface = i
+        end
+      end
+      interface
+    end
+    
+  end
+
+end

data/lib/vidalia/object.rb

@@ -0,0 +1,139 @@
+module Vidalia
+
+  class Object < Artifact
+ 
+    attr_reader :name, :parent, :added_methods
+
+    @@methodlist = Hash.new
+
+    # Define an Object
+    #
+    # This routine takes a Vidalia::InterfaceDefinition and adds an Object
+    # definition to the associated Interface.
+    #
+    # *Options*
+    #
+    # Takes a hash as input where the current options are:
+    # +name+:: specifies the name of the Object
+    # +interface+:: specifies the Vidalia::InterfaceDefinition that the Object is associated with
+    #
+    # +block+:: specifies the block of code to be run when the Object is initialized
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    #
+    def self.define(opts = {}, &block)
+      Vidalia::ObjectDefinition.new(opts,&block)
+    end
+
+
+    # Create an Object (inherited from Vidalia::Artifact)
+    #
+    # Initializes a Vidalia::Object using the data set in 
+    # Vidalia::Object.define.  If such data does not exist, this routine will 
+    # error out.  This ensures that all Objects have been predefined.
+    #
+    # *Options*
+    #
+    # Takes a hash as input where the current options are:
+    # +name+:: specifies the name of the Object
+    # +parent+:: specifies the parent object
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    #
+    def initialize(opts = {})
+      o = {
+        :name => nil,
+        :parent => nil,
+        :definition => nil
+      }.merge(opts)
+
+      @type = Vidalia::Object
+      super
+      @added_methods = Hash.new
+      if o[:definition]
+        my_def = o[:definition]
+        Vidalia::checkvar(my_def,Vidalia::Object,self.class.ancestors,"definition")
+        my_def.added_methods.each do |method_name,block|
+          @added_methods[method_name] = block
+        end
+      end
+    end
+
+
+    # Retrieve a child Element of this Object by name
+    #
+    # *Options*
+    #
+    # This method takes one parameter:
+    # +name+:: specifies the name of the child Element
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    #
+    def element(name)
+      Vidalia::checkvar(name,String,self.class.ancestors,"name")
+      child = get_child(name)
+      unless child
+        # Child does not yet exist.  Create it.
+        child = Vidalia::Element.new(
+          :name => name,
+          :parent => self,
+          :definition => @source_artifact.get_child(name)
+        )
+      end
+      child
+    end
+  
+    
+    # Define a method to act on a given Object
+    #
+    # *Options*
+    #
+    # Takes a hash as input where the current options are:
+    # +name+:: specifies the name of the method
+    # +token+:: specifies the Vidalia::ArtifactToken of the Object
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    # 
+    def add_method(opts = {},&block)
+      o = {
+        :name => nil
+      }.merge(opts)
+      Vidalia::checkvar(o[:name],String,self.class.ancestors,"name")
+      @added_methods[o[:name]] = block
+    end
+   
+ 
+    # Add a pre-defined instance method to this Class
+    #
+    # *Options*
+    #
+    # Takes a hash as input where the current options are:
+    # +name+:: specifies the name of the method
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    # 
+    def self.define_method_for_object_class(name)
+      Vidalia::checkvar(name,String,self.class.ancestors,"name")
+      define_method name.to_sym do |opts = {}|
+        if @added_methods[name]
+          block = @added_methods[name]
+          instance_exec(opts,&block)
+        else
+          raise "Tried to call an Object method that doesn't exist."
+        end
+      end
+    end
+    
+  end
+
+end

data/lib/vidalia/object_definition.rb

@@ -0,0 +1,77 @@
+module Vidalia
+
+  class ObjectDefinition
+
+    attr_reader :name, :parent, :children, :object
+
+    @@defined_method_names = {}
+
+    # Create an Object Definition
+    #
+    # Under the covers, the ObjectDefinition will create an associated
+    # Object definition.  Any instantiated Object under the parent Interface
+    # will be copied from this master copy.
+    #
+    # *Options*
+    #
+    # Takes two parameters:
+    # Takes a hash as input where the current options are:
+    # +name+:: (required) specifies the name of the Object
+    # +parent+:: (required) specifies the name of the parent Interface
+    # Takes a block to be executed at initialization time
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    #
+    def initialize(opts = {}, &block)
+      o = {
+        :name => nil,
+        :parent => nil
+      }.merge(opts)
+
+      Vidalia::checkvar(o[:name],String,self.class.ancestors,"name")
+      Vidalia::checkvar(o[:parent],Vidalia::InterfaceDefinition,self.class.ancestors,"parent")
+
+      o[:parent] = o[:parent].interface
+      @object = Vidalia::Object.new(o,&block)
+    end
+
+
+    # Define a method to act on a defined Object
+    #
+    # Define a method that any Vidalia::Object can run and save the method code in
+    # the Vidalia::Object represented with this definition
+    #
+    # *Options*
+    #
+    # Takes a hash as input where the current options are:
+    # +name+:: specifies the name of the method
+    # Takes a block that defines the code to run for that method
+    #
+    # *Example*
+    #
+    #   $$$ Example needed $$$
+    # 
+    def add_method(opts = {},&block)
+      o = {
+        :name => nil
+      }.merge(opts)
+
+      name = o[:name]
+      Vidalia::checkvar(name,String,self.class.ancestors,"name")
+
+      # Save the method code in the Vidalia::Object represented with this definition
+      @object.add_method(o,&block)
+
+      # Define a method that any Vidalia::Object can run
+      unless @@defined_method_names[name]
+        @@defined_method_names[name] = true
+        Vidalia::Object.define_method_for_object_class(name)
+      end
+
+    end
+   
+  end
+
+end

data/lib/vidalia.rb

@@ -0,0 +1,75 @@
+require 'vidalia/interface_definition'
+require 'vidalia/object_definition'
+require 'vidalia/element_definition'
+require 'vidalia/artifact'
+require 'vidalia/interface'
+require 'vidalia/object'
+require 'vidalia/element'
+
+# [cat]  something
+# something else
+#
+#
+# * Top level comment about Vidalia
+
+module Vidalia
+
+  # Configure the logging routine to be used by Vidalia for this thread.
+  #
+  # The routine you store here can be invoked by Vidalia.log
+  #
+  # *Options*
+  #
+  # +&block+:: specifies the code block to be called whenever Vidalia needs to invoke a logger.  This block should take a string followed by an optional hash as its parameters.
+  #
+  # *Example*
+  #
+  #   Vidalia.set_logroutine { |string,opts|
+  #     MyLogger::write(string,opts)
+  #   }
+  def Vidalia.set_logroutine(&block)
+    Thread.current[:vidalia_logroutine] = block
+  end 
+
+ 
+  # Write to the Vidalia log
+  #
+  # The log can be predefined by Vidalia.set_logroutine
+  #
+  # *Options*
+  #
+  # +string+:: specifies the string to write to the Vidalia log
+  # +opts+:: specifies a hash containing parameters to the Vidalia logging function
+  #
+  # *Example*
+  #
+  #   Vidalia.log("Everything is fine - no bugs here.",:style => fatal_error)
+  def Vidalia.log(string,opts = {})
+    return Thread.current[:vidalia_logroutine].call(string,opts)
+  end
+
+
+  # Check the type and existence of a variable
+  #
+  # *Options*
+  #
+  # +thing+:: specifies the veriable to check
+  # +thingtype+:: specifies the desired type of the variable data
+  # +procclass+:: specifies the class of the calling method
+  # +procname+:: specifies the name of the calling method
+  #
+  # *Example*
+  #
+  #   Vidalia.log("Everything is fine - no bugs here.",:style => fatal_error)
+  def Vidalia.checkvar(thing,thingtype,procclass,thingname)
+    if thing
+      unless thing.is_a?(thingtype)
+        raise "#{procclass.first}: #{thingname} should be a #{thingtype}, but was a #{thing.class} instead"
+      end
+    else
+      raise "#{procclass.first}: #{thingname} must be specified"
+    end
+  end
+
+
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: vidalia
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jeremy Rotter
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-04-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  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: Vidalia uses layers to simplify the creation and maintenance of API and
+  database calls in your automated test suite.
+email: jeremy.rotter@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/vidalia.rb
+- lib/vidalia/artifact.rb
+- lib/vidalia/element.rb
+- lib/vidalia/element_definition.rb
+- lib/vidalia/interface.rb
+- lib/vidalia/interface_definition.rb
+- lib/vidalia/object.rb
+- lib/vidalia/object_definition.rb
+homepage: https://github.com/jrotter/vidalia
+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.4.6
+signing_key: 
+specification_version: 4
+summary: Vidalia
+test_files: []