sapphire 0.7.26 → 0.8.0

data/lib/sapphire/DataAbstractions/Query.rb

@@ -1,21 +1,21 @@
-module Sapphire
-  module DataAbstractions
-    module Query
-      def Execute(block)
-          x = self.Database.new
-
-          x.Open $config[x.Connection]
-          y = ""
-          y = AppConfig.Current.SqlPath if AppConfig.Current
-          path = File.expand_path(y + self.Script, __FILE__)
-          file = File.open(path)
-          contents = file.read
-          self.Tokenize(contents)
-
-          results = x.query(contents)
-          block.call results
-          x.close
-        end
-      end
-  end
+module Sapphire
+  module DataAbstractions
+    module Query
+      def Execute(block)
+          x = self.Database.new
+
+          x.Open $config[x.Connection]
+          y = ""
+          y = AppConfig.Current.SqlPath if AppConfig.Current
+          path = File.expand_path(y + self.Script, __FILE__)
+          file = File.open(path)
+          contents = file.read
+          self.Tokenize(contents)
+
+          results = x.query(contents)
+          block.call results
+          x.close
+        end
+      end
+  end
 end

data/lib/sapphire/Extensions/Class.rb

@@ -1,7 +1,7 @@
 class Class < Module
 
-  def Clear
-    x = self.new
+  def Clear(item)
+    x = item.new
     x.Clear
   end
 

data/lib/sapphire/Extensions/Hash.rb

@@ -1,113 +1,113 @@
-class Hash < Object
-
-  def Set(hash)
-    hash.keys.first.Set(hash)
-  end
-
-  def For(item)
-    {item => GetPageField(item).Text}
-  end
-
-  def Examine(item, comparator, &block)
-
-    flip = false
-    key = GetKey(item) do |item| item.keys.first end
-
-    return FieldNotDefinedEvaluation.new(key, $page) if !$page.Contains key and !Parameters.instance.Contains key
-
-    field = $page.Get(key) if $page.Contains key
-
-    if(field.nil?)
-      key1 = GetKey(item) do |item| item[item.keys.first] end
-      if $page.Contains key1
-        field = $page.Get(key1)
-        flip = true
-      end
-    end
-
-    return Fix(Evaluation.new(Parameter(key), item.first[key]), comparator) if Parameters.instance.Contains(key) and field.nil?
-
-    return FieldNotFoundEvaluation.new(key, $page, "selenium could not find the field") if field == nil
-    evaluation = field.Evaluate(key, item, comparator, block)
-
-    if(flip)
-      left = evaluation.left
-      right = evaluation.right
-
-      evaluation.right = left
-      evaluation.left = right
-    end
-
-
-    return Fix(evaluation, comparator)
-  end
-
-  def GetKey(item, &block)
-    return block.call(item.first) if item.first.is_a? Hash
-    return item.first.first if item.first.is_a? Array
-  end
-
-  def Show(item, comparator)
-    Examine(item, comparator) do |field, value|
-      field.Equals(value, comparator)
-    end
-  end
-
-  def AltText(item, comparator)
-    Examine(item, comparator) do |field, value|
-      field.AltText(value, comparator)
-    end
-  end
-
-  def Source(item, comparator)
-    Examine(item, comparator) do |field, value|
-      field.Source(value, comparator)
-    end
-  end
-
-  def Contain(item, comparator)
-    Examine(item, comparator) do |field, value|
-      field.Contain(value)
-    end
-  end
-
-  def Count(item, comparator)
-    Examine(item, comparator) do |field, value|
-      field.Count(value)
-    end
-  end
-
-  def In(item, comparator)
-    Examine(item, comparator) do |field, value|
-      field.In(value, comparator)
-    end
-  end
-
-
-  def Validate(hash, comparator)
-    Fix(Evaluation.new(hash.keys.first.to_s, hash[hash.keys.first].to_s), comparator)
-  end
-
-  def Fix(evaluation, comparator)
-    comparator = comparator.Create(evaluation)
-    comparator
-  end
-
-  def Using(items)
-    $matrices ||= {}
-
-    master_array = []
-    master_array = $matrices[$matrix_variable] if $matrices.has_key? $matrix_variable
-
-    array = []
-
-    items.keys.each do |key|
-      array << Proc.new { Parameter key => items[key] }
-    end
-
-    master_array << array
-
-    $matrices.merge! $matrix_variable => master_array
-  end
-
+class Hash < Object
+
+  def Set(hash)
+    hash.keys.first.Set(hash)
+  end
+
+  def For(item)
+    {item => GetPageField(item).Text}
+  end
+
+  def Examine(item, comparator, &block)
+
+    flip = false
+    key = GetKey(item) do |item| item.keys.first end
+
+    return FieldNotDefinedEvaluation.new(key, $page) if !$page.Contains key and !Parameters.instance.Contains key
+
+    field = $page.Get(key) if $page.Contains key
+
+    if(field.nil?)
+      key1 = GetKey(item) do |item| item[item.keys.first] end
+      if $page.Contains key1
+        field = $page.Get(key1)
+        flip = true
+      end
+    end
+
+    return Fix(Evaluation.new(Parameter(key), item.first[key]), comparator) if Parameters.instance.Contains(key) and field.nil?
+
+    return FieldNotFoundEvaluation.new(key, $page, "selenium could not find the field") if field == nil
+    evaluation = field.Evaluate(key, item, comparator, block)
+
+    if(flip)
+      left = evaluation.left
+      right = evaluation.right
+
+      evaluation.right = left
+      evaluation.left = right
+    end
+
+
+    return Fix(evaluation, comparator)
+  end
+
+  def GetKey(item, &block)
+    return block.call(item.first) if item.first.is_a? Hash
+    return item.first.first if item.first.is_a? Array
+  end
+
+  def Show(item, comparator)
+    Examine(item, comparator) do |field, value|
+      field.Equals(value, comparator)
+    end
+  end
+
+  def AltText(item, comparator)
+    Examine(item, comparator) do |field, value|
+      field.AltText(value, comparator)
+    end
+  end
+
+  def Source(item, comparator)
+    Examine(item, comparator) do |field, value|
+      field.Source(value, comparator)
+    end
+  end
+
+  def Contain(item, comparator)
+    Examine(item, comparator) do |field, value|
+      field.Contain(value)
+    end
+  end
+
+  def Count(item, comparator)
+    Examine(item, comparator) do |field, value|
+      field.Count(value)
+    end
+  end
+
+  def In(item, comparator)
+    Examine(item, comparator) do |field, value|
+      field.In(value, comparator)
+    end
+  end
+
+
+  def Validate(hash, comparator)
+    Fix(Evaluation.new(hash.keys.first.to_s, hash[hash.keys.first].to_s), comparator)
+  end
+
+  def Fix(evaluation, comparator)
+    comparator = comparator.Create(evaluation)
+    comparator
+  end
+
+  def Using(items)
+    $matrices ||= {}
+
+    master_array = []
+    master_array = $matrices[$matrix_variable] if $matrices.has_key? $matrix_variable
+
+    array = []
+
+    items.keys.each do |key|
+      array << Proc.new { Parameter key => items[key] }
+    end
+
+    master_array << array
+
+    $matrices.merge! $matrix_variable => master_array
+  end
+
 end

data/lib/sapphire/Extensions/Module.rb

@@ -0,0 +1,11 @@
+class Module
+  def sub_modules
+    [self] + constants.map {|const| const_get(const) }
+    .select {|const| const.is_a? Module }
+    .flat_map {|const| const.sub_modules }
+  end
+
+  def sub_classes
+    self.constants.select {|c| Class === self.const_get(c)}
+  end
+end

data/lib/sapphire/Extensions/Numeric.rb

@@ -1,7 +1,7 @@
-class Numeric < Object
-
-  def Wait
-    sleep(self)
-  end
-
+class Numeric < Object
+
+  def Wait
+    sleep(self)
+  end
+
 end

data/lib/sapphire/Extensions/Object.rb

@@ -6,4 +6,8 @@ class Object
     return comparator.Create(evaluation)
   end
 
+  def self.observe()
+    include Sapphire::Observable
+  end
+
 end

data/lib/sapphire/Extensions/String.rb

@@ -1,24 +1,31 @@
-class String
-
-  alias_method :"plus", :"+"
-
-   def underscore
-       self.gsub(/::/, '/').
-       gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-       gsub(/([a-z\d])([A-Z])/,'\1_\2').
-       tr("-", "_").
-       downcase
-   end
-
-  def +(item)
-    return plus(Parameter(item)) if Sapphire::DSL::TestPlans::Parameters.instance.Contains(item)
-    raise "No Parameter defined for: " << item.to_s if item.is_a? Symbol
-
-    plus(item)
-  end
-
-  def For(item)
-    item
-  end
-
+class String
+
+  alias_method :"plus", :"+"
+
+  def underscore
+     self.gsub(/::/, '/').
+     gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+     gsub(/([a-z\d])([A-Z])/,'\1_\2').
+     tr("-", "_").
+     downcase
+  end
+
+  def +(item)
+    return plus(Parameter(item)) if Sapphire::DSL::TestPlans::Parameters.instance.Contains(item)
+    raise "No Parameter defined for: " << item.to_s if item.is_a? Symbol and !item.nil?
+
+    plus(item)
+  end
+
+  def For(item)
+    item
+  end
+
+  def namespace
+    self.gsub(/::/, '_').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_")
+  end
+
 end

data/lib/sapphire/Extensions/Symbol.rb

@@ -1,6 +1,6 @@
 class Symbol
 
-  def Clear
+  def Clear(item)
     ExecuteAgainstControl(self) do |control, arg|
       control.Clear
     end

data/lib/sapphire/JobAbstractions/Job.rb

@@ -1,32 +1,32 @@
-module Sapphire
-  module JobAbstractions
-    class Job
-
-      def Server
-        return ""
-      end
-
-      def User
-        return ""
-      end
-
-      def Password
-        return ""
-      end
-
-      def Path
-        return ""
-      end
-
-      def PsExecPath
-        return ""
-      end
-
-      def Arg
-        return nil
-      end
-
-    end
-  end
-end
-
+module Sapphire
+  module JobAbstractions
+    class Job
+
+      def Server
+        return ""
+      end
+
+      def User
+        return ""
+      end
+
+      def Password
+        return ""
+      end
+
+      def Path
+        return ""
+      end
+
+      def PsExecPath
+        return ""
+      end
+
+      def Arg
+        return nil
+      end
+
+    end
+  end
+end
+

data/lib/sapphire/Observable.rb

@@ -0,0 +1,87 @@
+module Sapphire
+  module Observable
+    def self.intercept(base, hash, *method_names)
+      do_before = proc { |name, inst, args|
+        begin
+          hash[:before].call(name, inst, args)
+        rescue => observer_exception
+
+        end
+      }
+
+      do_on_success = proc { |name, inst, args|
+        begin
+          hash[:success].call(name, inst, args)
+        rescue => raised_exception
+          raise raised_exception
+        end
+      }
+
+      do_on_failure = proc { |name, inst, raised_exception, args|
+        begin
+          hash[:failure].call(name, inst, raised_exception, args)
+        rescue => observer_exception
+
+        end
+      }
+
+      do_after = proc { |name, inst, args|
+        begin
+          hash[:after].call(name, inst, args)
+        rescue => observer_exception
+
+        end
+      }
+
+      method_names.each do |method_name|
+        method = base.instance_method(method_name)
+        base.send :define_method, method_name.to_sym do |*args, &method_block|
+          do_before.call(method_name, self, args) if hash.has_key? :before
+          begin
+            result = method.bind(self).(*args, &method_block)
+            do_on_success.call(method_name, self, args) if hash.has_key? :after
+            return result
+          rescue => raised_exception
+            do_on_failure.call(method_name, self, raised_exception, args) if hash.has_key? :failure
+            raise raised_exception
+          ensure
+            do_after.call(method_name, self, args) if hash.has_key? :success
+          end
+        end
+      end
+    end
+
+    def self.included(base)
+      before = proc { |name, inst, args|
+        observers = Observers::ObserverRepository.instance.Find(name.to_sym, inst.class)
+        observers.each do |x| x.Before(inst, name, args) if x.respond_to? :Before end
+      }
+
+      after = proc { |name, inst, args|
+        observers = Observers::ObserverRepository.instance.Find(name.to_sym, inst.class)
+        observers.each do |x| x.After(inst, name, args) if x.respond_to? :After end
+      }
+
+      success = proc { |name, inst, args|
+        observers = Observers::ObserverRepository.instance.Find(name.to_sym, inst.class)
+        observers.each do |x| x.OnSuccess(inst, name, args) if x.respond_to? :OnSuccess end
+      }
+
+
+      failure = proc { |name, inst, exception, args|
+        observers = Observers::ObserverRepository.instance.Find(name.to_sym, inst.class)
+        observers.each do |x| x.OnFailure(inst, name, exception, args) if x.respond_to? :OnFailure end
+      }
+
+
+      hash = {}
+
+      hash.merge! :before => before,
+                  :after => after,
+                  :failure => failure,
+                  :success => success
+
+      intercept(base, hash, *base.instance_methods(false))
+    end
+  end
+end