watirmark 5.14.16

data/lib/watirmark/models/debug_methods.rb

@@ -0,0 +1,21 @@
+module Watirmark
+  module Model
+
+    DebugModelValues = Hash.new{|h,k| h[k]=Hash.new}
+
+    module DebugMethods
+      def model_name=(name)
+        @model_name = name
+        add_debug_overrides
+      end
+
+      def add_debug_overrides
+        return unless @model_name && DebugModelValues != {}
+        Watirmark.logger.warn "Adding DEBUG overrides for #@model_name"
+        update DebugModelValues['*'] if DebugModelValues['*']
+        update DebugModelValues[@model_name] if DebugModelValues[@model_name]
+      end
+    end
+
+  end
+end

data/lib/watirmark/models/default_values.rb

@@ -0,0 +1,21 @@
+module Watirmark
+  module Model
+    class DefaultValues < Hash
+
+      # This is a workaround for zip being defined in Enumerable and
+      # we want to use zip in the model as a zip code
+      undef :zip
+
+      # This works around an issue that gets hit when
+      # running from rake and the model has default.desc set.
+      # If we don't have it here it thinks we're trying to call rakes' #desc
+      def desc(&block)
+        self[:desc] = block
+      end
+
+      def method_missing(name, &block)
+        self[name] = block
+      end
+    end
+  end
+end

data/lib/watirmark/models/factory.rb

@@ -0,0 +1,168 @@
+require_relative 'cucumber_helper'
+require_relative 'default_values'
+require_relative 'factory_methods'
+require_relative 'factory_method_generators'
+require_relative 'debug_methods'
+
+module Watirmark
+  module Model
+
+    class Factory
+      extend FactoryMethods
+
+      include CucumberHelper
+      include DebugMethods
+      include FactoryMethodGenerators
+
+      attr_accessor :defaults, :model_name, :models, :parent, :children, :model_type
+      attr_reader   :keywords
+
+      def initialize(params={})
+        @params = params
+        @model_type = self.class.model_type_name
+        @search     = self.class.search || Proc.new{nil}
+        @keywords   = self.class.keys.dup || []
+        @children   = self.class.children.dup.map(&:new)
+        set_model_name
+        set_default_values
+        create_model_getters_and_setters
+        set_initial_values
+        Watirmark.logger.info inspect
+      end
+
+      def uuid
+        @uuid ||= (Watirmark::Configuration.instance.uuid || UUID.new.generate(:compact)[0..9]).to_s
+      end
+
+      def strip_equals_from_method_name(method)
+        method.to_s.delete('=').to_sym
+      end
+
+      # The search_term, used for a controller's search can be defined in this model
+      # or will look in a parent's model. This allows us to define it once for a composed model
+      def search_term
+        instance_eval(&@search) || (parent.search_term if parent)
+      end
+
+
+      def add_model(model)
+        @children << model
+        create_child_methods
+        Watirmark.logger.info "Added Model #{model.inspect} to #{model_name || model_class_name}"
+      end
+
+
+      def find(model_class)
+        return self if self.kind_of? model_class
+        @children.each do |m|
+          return m if m.model_type == model_class
+          found_model = m.find model_class
+          return found_model if found_model
+        end
+        nil
+      end
+
+
+      def inspect
+        model_friendly_name = @model_name ? "#@model_name: " : nil
+        model_details = " #{to_h}" unless to_h.empty?
+        included_models = "\n   #{@children.map(&:inspect).join("\n   ")}" unless @children.empty?
+        "#{model_friendly_name}#{model_class_name}#{model_details}#{included_models}"
+      end
+
+
+      def model_class_name
+        name = self.class.inspect.to_s
+        name = self.class.superclass.to_s if name.to_s =~ /Class/
+        name = 'Model' if name.to_s =~ /Module/
+        name.sub!(/.+::/,'')
+        name
+      end
+
+
+      def includes? hash
+        hash.each_pair { |key, value| return false unless send("#{key}") == value }
+        true
+      end
+
+
+      # Update the model using the provided hash
+      def update hash
+        remove_empty_entries hash
+        hash.each_pair { |key, value| send "#{key}=", value }
+        self
+      end
+
+
+      # Update the model using the provided hash but only if exists (TODO: may not be needed any more)
+      def update_existing_members hash
+        remove_empty_entries hash
+        hash.each_pair { |key, value| send "#{key}=", value if respond_to? "#{key}=".to_sym }
+        self
+      end
+
+      def remove_empty_entries hash
+        hash.delete(':')
+        hash.delete_if {|k| k =~ /^\s+$/}
+      end
+
+      def to_h
+        h = {}
+        @keywords.each do |key|
+          begin
+            name = key
+            value = send(key)
+            if value.kind_of?(Proc)
+              h[name] = instance_eval(&value) unless value.nil?
+            else
+              h[name] = value unless value.nil?
+            end
+          rescue NoMethodError
+            h[name] = "[defined at runtime]"
+          end
+        end
+        h
+      end
+
+
+    private
+
+      def set_model_name
+        if @params[:model_name]
+          @model_name = @params[:model_name]
+          @params.delete(:model_name)
+        end
+      end
+
+      def create_model_getters_and_setters
+        create_keyword_methods
+        create_child_methods
+      end
+
+      def set_default_values
+        @defaults = self.class.default.dup
+        @traits = self.class.included_traits || []
+        include_defaults_from_traits @traits
+      end
+
+      def set_initial_values
+        update @params
+        add_debug_overrides
+      end
+
+
+      def include_defaults_from_traits(traits)
+        traits.each do |trait_name|
+          trait = Watirmark::Model::Traits.instance[trait_name]
+          trait.defaults.each {|k, v| @defaults[k] = v unless @defaults.key?(k)}
+          trait.traits.each {|t| include_defaults_from_traits([t])}
+        end
+      end
+
+      def method_name model
+        model.model_class_name.to_s.sub(/Model$/, '').underscore
+      end
+
+    end
+  end
+end

data/lib/watirmark/models/factory_method_generators.rb

@@ -0,0 +1,84 @@
+module Watirmark
+  module Model
+    module FactoryMethodGenerators
+
+      # Act like an OpenStruct so we can be backward compatible with older controllers
+      def method_missing(key, *args, &block)
+        create_getters_and_setters strip_equals_from_method_name(key)
+        send key, *args
+      end
+
+      private
+
+      def create_keyword_methods
+        @keywords.each do |key|
+          create_getters_and_setters key
+          set_default_value key
+        end
+      end
+
+      def create_getters_and_setters key
+        @keywords << key unless @keywords.include? key #handle call from method_missing
+        create_getter_method key
+        create_setter_method key
+      end
+
+      def create_getter_method(key)
+        meta_def key do
+          normalize instance_variable_get("@#{key}")
+        end
+      end
+
+      def create_setter_method(key)
+        meta_def "#{key}=" do |value|
+          instance_variable_set "@#{key}", value
+        end
+      end
+
+      def set_default_value key
+        send("#{key}=", get_default_value(key)) if send(key).nil?
+      end
+
+      def get_default_value(key)
+        @defaults.key?(key) ? @defaults[key] : nil
+      end
+
+      # if the value is a proc, evaluate it, otherwise just return
+      def normalize(val)
+        val.kind_of?(Proc) ? instance_eval(&val) : val
+      end
+
+
+      def create_child_methods
+        @children.each do |model|
+          model.parent = self
+          create_model_collection model
+          create_model_method model
+        end
+      end
+
+      def collection_name model
+        method_name(model).pluralize
+      end
+
+
+      def create_model_collection model
+        @collection ||= []
+        @collection << model unless @collection.include? model
+        meta_def collection_name(model).pluralize do
+          @collection
+        end
+      end
+
+
+      def create_model_method model
+        unless respond_to? method_name(model)
+          meta_def method_name(model) do
+            model
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/watirmark/models/factory_methods.rb

@@ -0,0 +1,72 @@
+module Watirmark
+  module Model
+    module FactoryMethods
+      attr_accessor :search, :model_type_name, :included_traits
+      attr_writer :default, :keys
+
+      def inherited(klass)
+        unless self == Factory
+          add_keywords_to_subclass klass
+          add_defaults_to_subclass klass
+          add_traits_to_subclass klass
+        end
+      end
+
+      def default
+        @default ||= DefaultValues.new
+      end
+
+      def keys
+        @keys ||= []
+      end
+
+      def defaults(&block)
+        default.instance_exec &block
+      end
+
+      def children
+        @children ||= []
+      end
+
+      def model *models
+        models.each { |model| raise Watirmark::ModelCreationError unless Class === model }
+        @children = children + models
+        @children.uniq!
+      end
+
+      def model_type(c_name)
+        @model_type_name = c_name
+      end
+
+      def search_term &block
+        @search = block
+      end
+
+      def traits(*names)
+        @included_traits = [*names].flatten
+      end
+
+      def keywords(*args)
+        @keys = [*args].flatten
+      end
+
+      private
+
+      def add_keywords_to_subclass klass
+        if @keys
+          klass.keys = []
+          klass.keys += @keys.dup
+        end
+      end
+
+      def add_defaults_to_subclass klass
+        klass.default = @default.dup if @default
+      end
+
+      def add_traits_to_subclass klass
+        klass.included_traits = @included_traits.dup if @included_traits
+      end
+
+    end
+  end
+end

data/lib/watirmark/models/trait.rb

@@ -0,0 +1,35 @@
+require 'singleton'
+module Watirmark
+  module Model
+    def self.trait(name, &block)
+      new_trait = Trait.new
+      new_trait.instance_eval(&block)
+      Watirmark::Model::Traits.instance[name] = new_trait
+    end
+
+    class Trait
+      attr_accessor :defaults
+
+      def initialize
+        @defaults = {}
+        @traits = []
+      end
+
+      def traits(*names)
+        if names.empty?
+          @traits
+        else
+          @traits += names
+        end
+      end
+
+      def method_missing(sym, *args, &block)
+        @defaults[sym] = block
+      end
+    end
+
+    class Traits < Hash
+      include Singleton
+    end
+  end
+end

data/lib/watirmark/models/upload_csv.rb

@@ -0,0 +1,24 @@
+module Watirmark
+  module Model
+    class UploadCSV < Factory
+      require 'csv'
+      require 'tempfile'
+
+      def create_csv(table)
+        Watirmark.logger.info "Creating temporary CSV: #{csv_file}"
+        Watirmark.logger.info table.inspect
+        CSV.open(csv_file, 'wb') do |csv|
+          table.each do |line|
+            csv << line
+          end
+        end
+      end
+
+      def csv_file
+        @file ||= Tempfile.new(%w(csv_data .csv))
+        @file.path
+      end
+
+    end
+  end
+end

data/lib/watirmark/page/keyed_element.rb

@@ -0,0 +1,63 @@
+require 'watirmark/page/radio_maps'
+
+module Watirmark
+
+  module KeywordMethods
+    attr_accessor :keyword, :radio_map
+  end
+
+  class KeyedElement
+    attr_reader :keyword, :process_page, :permissions
+
+    def initialize(context, options)
+      @context      = context
+      @keyword      = options[:keyword]
+      @block        = options[:block]
+      @process_page = options[:process_page]
+      @permissions  = options[:permissions] || {}
+      @map = Watirmark::RadioMap.new(options[:map]) if options[:map]
+    end
+
+    def get *args
+      @process_page.activate
+      watir_object = @context.instance_exec(*args, &@block)
+      watir_object.extend(KeywordMethods)
+      watir_object.radio_map = @map if @map
+      watir_object.keyword = @keyword
+      watir_object
+    end
+
+    def set val
+      return if val.nil?
+      @process_page.activate
+      element = get
+      val = @map.lookup(val) if @map
+      case val
+        when 'nil'
+          element.clear # workaround to empty element values
+        else
+          case element
+            when Watir::Radio
+              element.set val
+            when Watir::CheckBox
+              val ? element.set : element.clear
+            when Watir::Select
+              element.select val
+            when Watir::Button
+              element.click
+            else
+              element.value = val
+          end
+      end
+    end
+
+    def populate_allowed?
+      @permissions[:populate]
+    end
+
+    def verify_allowed?
+      @permissions[:verify]
+    end
+
+  end
+end