insite 0.0.2 → 0.0.5

data/lib/insite/element/element.rb

@@ -0,0 +1,147 @@
+require_relative '../component/component_methods.rb'
+require_relative '../component/component_instance_methods.rb'
+
+module Insite
+  class Element
+    attr_reader :target, :site
+
+    class << self
+      attr_reader :predefined_selector
+    end
+
+    include Insite::CommonMethods
+    extend  Insite::DOMMethods
+    include Insite::ElementInstanceMethods
+    extend  Insite::ComponentMethods
+    include Insite::ComponentInstanceMethods
+    extend  Forwardable
+
+    def self.collection?
+      false
+    end
+
+    def attributes
+      nokogiri.xpath("//#{selector[:tag_name]}")[0].attributes.values.map do |x|
+        [x.name, x.value]
+      end.to_h
+    end
+
+    def classes
+      attribute('class').split
+    end
+
+    def collection?
+      false
+    end
+
+    def initialize(parent, *args)
+      parent.respond_to?(:target) ? obj = parent : obj = parent.site
+      @parent   = obj
+
+      @site     = parent.class.ancestors.include?(Insite) ? parent : parent.site
+      @browser  = @site.browser
+
+      if args[0].is_a?(Insite::Element) || args[0].is_a?(Insite::ElementCollection)
+        @target   = args[0].target
+        @selector = @target.selector.dup
+        @args     = @selector
+      elsif  args[0].is_a?(Watir::Element) || args[0].is_a?(Watir::ElementCollection)
+        @args     = nil
+        @selector = @target.instance_variable_get(:@selector).dup
+        @args     = @selector
+      else
+        if [Insite::Element, Insite::HTMLElement].include?(self.class)
+          @args = parse_args(args.dup)
+        elsif tag = parse_args(args)[:tag_name]
+          @args = parse_args(args.dup)
+        elsif Insite.class_to_tag(self.class)
+          @args = parse_args(args.dup).merge(
+            tag_name: Insite.class_to_tag(self.class)
+          )
+        else
+          @args = parse_args(args.dup)
+        end
+        @selector = @args
+
+        if watir_class = Insite::CLASS_MAP.key(self.class)
+          @target = watir_class.new(@parent.target, @args)
+        else
+          @target = Watir::HTMLElement.new(@parent.target, @args)
+        end
+      end
+    end
+
+    # def initialize(site, element)
+    #   @site    = site
+    #   @browser = @site.browser
+    #   @target  = element
+    #
+    #   # Temporary replacement for custom wait_until.
+    #   # TODO: Continue looking at scolling solutions.
+    #   if @target.present? && @target.respond_to?(:scroll)
+    #     @target.scroll.to
+    #     t = ::Time.now + 2
+    #     while ::Time.now <= t do
+    #       break if @target.present?
+    #       sleep 0.1
+    #     end
+    #   end
+    #
+    #   @target
+    # end
+
+    def inspect
+      if @target.selector.present?
+        s = @selector.to_s
+      else
+        s = '{element: (selenium element)}'
+      end
+      "#<#{self.class}: located: #{!!@target.element}; @selector=#{s}>"
+    end
+
+    # For page component code.
+    def method_missing(mth, *args, &block)
+      if @target.respond_to? mth
+        out = @target.send(mth, *args, &block)
+      elsif @target.class.descendants.any? { |x| x.instance_methods.include? mth }
+        out = @target.to_subtype.send(mth, *args, &block)
+      else
+        super
+      end
+
+      if out == @target
+        self
+      elsif out.is_a?(Watir::Element) || out.is_a?(Watir::ElementCollection)
+         Insite::CLASS_MAP[out.class].new(@parent, out)
+      else
+        out
+      end
+    end
+
+    def present?
+      sleep 0.1
+      begin
+        if @parent
+          if @parent.respond_to?(:present?) && @parent.present? && @target.present?
+            true
+          else
+            false
+          end
+        else
+          if @target.present?
+            true
+          else
+            false
+          end
+        end
+      rescue => e
+        false
+      end
+    end
+
+    def respond_to_missing?(mth, include_priv = false)
+      @target.respond_to?(mth, include_priv) || super
+    end
+  end
+
+end

data/lib/insite/element/element_collection.rb

@@ -0,0 +1,102 @@
+module Insite
+  class ElementCollection < Element
+    attr_accessor :browser
+    attr_reader :selector
+
+    def self.collection?
+      true
+    end
+
+    def ==(other)
+      to_a == other.to_a
+    end
+    alias eql? ==
+
+    def[](idx)
+      to_a[idx]
+    end
+
+    def collection?
+      true
+    end
+
+    def self.collection_member_type
+      if Insite::CLASS_MAP.values.include?(self)
+        @collection_member_type = self.to_s.gsub('Collection', '').constantize
+      elsif Insite::CLASS_MAP.values.include?(self.superclass)
+        @collection_member_type = self.superclass.to_s.gsub('Collection', '').constantize
+      else
+        raise "Unable to determine collection member type for #{self}."
+      end
+    end
+
+    def initialize(parent, *args)
+      @collection_member_type = self.class.collection_member_type
+
+      # Figure out the correct query scope.
+      parent.respond_to?(:target) ? obj = parent : obj = parent.site
+      @parent   = obj
+      @site     = parent.class.ancestors.include?(Insite) ? parent : parent.site
+      @browser  = @site.browser
+      if args[0].is_a?(Insite::Element) || args[0].is_a?(Insite::ElementCollection)
+        @target   = args[0].target
+        @args     = @target.selector.dup
+        @selector = @args
+      elsif  args[0].is_a?(Watir::Element) || args[0].is_a?(Watir::ElementCollection)
+        @target   = args[0]
+        @args     = @target.instance_variable_get(:@selector).dup
+        @selector   = @args
+      else
+        if @collection_member_type == Insite::HTMLElement
+          @args     = parse_args(args)
+          @selector = @args
+          @target   = Watir::HTMLElementCollection.new(@parent.target, @args)
+        else
+          @args   = parse_args(args).merge(
+            tag_name: Insite.class_to_tag(@collection_member_type)
+          )
+          @selector = @args
+          @target   = Insite::CLASS_MAP.key(self.class).new(@parent.target, @args)
+        end
+      end
+    end
+
+    def first
+      to_a[0]
+    end
+
+    def each(&block)
+      to_a.each(&block)
+    end
+
+    def empty?
+      length == 0
+    end
+
+    def inspect
+      @selector.empty? ? s = '{element: (selenium element)}' : s = @selector.to_s
+      "#<#{self.class}: @parent: #{@parent}; @selector=#{s}>"
+    end
+
+    def last
+      to_a[-1]
+    end
+
+    def length
+      to_a.length
+    end
+    alias count length
+    alias size length
+
+    def to_a
+      out = []
+      @target.to_a.each_with_index do |elem, idx|
+        out << @collection_member_type.new(
+          @parent,
+          @args.merge(index: idx)
+        )
+      end
+      out
+    end
+  end
+end

data/lib/insite/element/generated/class_map.rb

@@ -0,0 +1,244 @@
+module Insite
+  CLASS_MAP = {
+    Watir::Anchor => Insite::Anchor,
+    Watir::AnchorCollection => Insite::AnchorCollection,
+    Watir::Applet => Insite::Applet,
+    Watir::AppletCollection => Insite::AppletCollection,
+    Watir::Area => Insite::Area,
+    Watir::AreaCollection => Insite::AreaCollection,
+    Watir::Audio => Insite::Audio,
+    Watir::AudioCollection => Insite::AudioCollection,
+    Watir::BR => Insite::BR,
+    Watir::BRCollection => Insite::BRCollection,
+    Watir::Base => Insite::Base,
+    Watir::BaseCollection => Insite::BaseCollection,
+    Watir::Body => Insite::Body,
+    Watir::BodyCollection => Insite::BodyCollection,
+    Watir::Button => Insite::Button,
+    Watir::ButtonCollection => Insite::ButtonCollection,
+    Watir::Canvas => Insite::Canvas,
+    Watir::CanvasCollection => Insite::CanvasCollection,
+    Watir::Cell => Insite::Cell,
+    Watir::CellCollection => Insite::CellCollection,
+    Watir::CheckBox => Insite::CheckBox,
+    Watir::CheckBoxCollection => Insite::CheckBoxCollection,
+    Watir::Circle => Insite::Circle,
+    Watir::CircleCollection => Insite::CircleCollection,
+    Watir::Cursor => Insite::Cursor,
+    Watir::CursorCollection => Insite::CursorCollection,
+    Watir::DList => Insite::DList,
+    Watir::DListCollection => Insite::DListCollection,
+    Watir::Data => Insite::Data,
+    Watir::DataCollection => Insite::DataCollection,
+    Watir::DataList => Insite::DataList,
+    Watir::DataListCollection => Insite::DataListCollection,
+    Watir::DateField => Insite::DateField,
+    Watir::DateFieldCollection => Insite::DateFieldCollection,
+    Watir::DateTimeField => Insite::DateTimeField,
+    Watir::DateTimeFieldCollection => Insite::DateTimeFieldCollection,
+    Watir::Defs => Insite::Defs,
+    Watir::DefsCollection => Insite::DefsCollection,
+    Watir::Desc => Insite::Desc,
+    Watir::DescCollection => Insite::DescCollection,
+    Watir::Details => Insite::Details,
+    Watir::DetailsCollection => Insite::DetailsCollection,
+    Watir::Directory => Insite::Directory,
+    Watir::DirectoryCollection => Insite::DirectoryCollection,
+    Watir::Div => Insite::Div,
+    Watir::DivCollection => Insite::DivCollection,
+    Watir::Ellipse => Insite::Ellipse,
+    Watir::EllipseCollection => Insite::EllipseCollection,
+    Watir::Embed => Insite::Embed,
+    Watir::EmbedCollection => Insite::EmbedCollection,
+    Watir::FieldSet => Insite::FieldSet,
+    Watir::FieldSetCollection => Insite::FieldSetCollection,
+    Watir::FileField => Insite::FileField,
+    Watir::FileFieldCollection => Insite::FileFieldCollection,
+    Watir::Font => Insite::Font,
+    Watir::FontCollection => Insite::FontCollection,
+    Watir::ForeignObject => Insite::ForeignObject,
+    Watir::ForeignObjectCollection => Insite::ForeignObjectCollection,
+    Watir::Form => Insite::Form,
+    Watir::FormCollection => Insite::FormCollection,
+    Watir::Frame => Insite::Frame,
+    Watir::FrameCollection => Insite::FrameCollection,
+    Watir::FrameSet => Insite::FrameSet,
+    Watir::FrameSetCollection => Insite::FrameSetCollection,
+    Watir::G => Insite::G,
+    Watir::GCollection => Insite::GCollection,
+    Watir::Geometry => Insite::Geometry,
+    Watir::GeometryCollection => Insite::GeometryCollection,
+    Watir::Gradient => Insite::Gradient,
+    Watir::GradientCollection => Insite::GradientCollection,
+    Watir::Graphics => Insite::Graphics,
+    Watir::GraphicsCollection => Insite::GraphicsCollection,
+    Watir::HR => Insite::HR,
+    Watir::HRCollection => Insite::HRCollection,
+    Watir::HTMLElement => Insite::HTMLElement,
+    Watir::HTMLElementCollection => Insite::HTMLElementCollection,
+    Watir::Hatch => Insite::Hatch,
+    Watir::HatchCollection => Insite::HatchCollection,
+    Watir::Hatchpath => Insite::Hatchpath,
+    Watir::HatchpathCollection => Insite::HatchpathCollection,
+    Watir::Head => Insite::Head,
+    Watir::HeadCollection => Insite::HeadCollection,
+    Watir::Heading => Insite::Heading,
+    Watir::HeadingCollection => Insite::HeadingCollection,
+    Watir::Hidden => Insite::Hidden,
+    Watir::HiddenCollection => Insite::HiddenCollection,
+    Watir::Html => Insite::Html,
+    Watir::HtmlCollection => Insite::HtmlCollection,
+    Watir::IFrame => Insite::IFrame,
+    Watir::IFrameCollection => Insite::IFrameCollection,
+    Watir::Image => Insite::Image,
+    Watir::ImageCollection => Insite::ImageCollection,
+    Watir::Input => Insite::Input,
+    Watir::InputCollection => Insite::InputCollection,
+    Watir::Keygen => Insite::Keygen,
+    Watir::KeygenCollection => Insite::KeygenCollection,
+    Watir::LI => Insite::LI,
+    Watir::LICollection => Insite::LICollection,
+    Watir::Label => Insite::Label,
+    Watir::LabelCollection => Insite::LabelCollection,
+    Watir::Legend => Insite::Legend,
+    Watir::LegendCollection => Insite::LegendCollection,
+    Watir::Line => Insite::Line,
+    Watir::LineCollection => Insite::LineCollection,
+    Watir::LinearGradient => Insite::LinearGradient,
+    Watir::LinearGradientCollection => Insite::LinearGradientCollection,
+    Watir::Map => Insite::Map,
+    Watir::MapCollection => Insite::MapCollection,
+    Watir::Marker => Insite::Marker,
+    Watir::MarkerCollection => Insite::MarkerCollection,
+    Watir::Marquee => Insite::Marquee,
+    Watir::MarqueeCollection => Insite::MarqueeCollection,
+    Watir::Media => Insite::Media,
+    Watir::MediaCollection => Insite::MediaCollection,
+    Watir::Menu => Insite::Menu,
+    Watir::MenuCollection => Insite::MenuCollection,
+    Watir::MenuItem => Insite::MenuItem,
+    Watir::MenuItemCollection => Insite::MenuItemCollection,
+    Watir::Mesh => Insite::Mesh,
+    Watir::MeshCollection => Insite::MeshCollection,
+    Watir::MeshGradient => Insite::MeshGradient,
+    Watir::MeshGradientCollection => Insite::MeshGradientCollection,
+    Watir::Meshpatch => Insite::Meshpatch,
+    Watir::MeshpatchCollection => Insite::MeshpatchCollection,
+    Watir::Meshrow => Insite::Meshrow,
+    Watir::MeshrowCollection => Insite::MeshrowCollection,
+    Watir::Meta => Insite::Meta,
+    Watir::MetaCollection => Insite::MetaCollection,
+    Watir::Metadata => Insite::Metadata,
+    Watir::MetadataCollection => Insite::MetadataCollection,
+    Watir::Meter => Insite::Meter,
+    Watir::MeterCollection => Insite::MeterCollection,
+    Watir::Mod => Insite::Mod,
+    Watir::ModCollection => Insite::ModCollection,
+    Watir::OList => Insite::OList,
+    Watir::OListCollection => Insite::OListCollection,
+    Watir::Object => Insite::Object,
+    Watir::ObjectCollection => Insite::ObjectCollection,
+    Watir::OptGroup => Insite::OptGroup,
+    Watir::OptGroupCollection => Insite::OptGroupCollection,
+    Watir::Option => Insite::Option,
+    Watir::OptionCollection => Insite::OptionCollection,
+    Watir::Output => Insite::Output,
+    Watir::OutputCollection => Insite::OutputCollection,
+    Watir::Paragraph => Insite::Paragraph,
+    Watir::ParagraphCollection => Insite::ParagraphCollection,
+    Watir::Param => Insite::Param,
+    Watir::ParamCollection => Insite::ParamCollection,
+    Watir::Path => Insite::Path,
+    Watir::PathCollection => Insite::PathCollection,
+    Watir::Pattern => Insite::Pattern,
+    Watir::PatternCollection => Insite::PatternCollection,
+    Watir::Picture => Insite::Picture,
+    Watir::PictureCollection => Insite::PictureCollection,
+    Watir::Polygon => Insite::Polygon,
+    Watir::PolygonCollection => Insite::PolygonCollection,
+    Watir::Polyline => Insite::Polyline,
+    Watir::PolylineCollection => Insite::PolylineCollection,
+    Watir::Pre => Insite::Pre,
+    Watir::PreCollection => Insite::PreCollection,
+    Watir::Progress => Insite::Progress,
+    Watir::ProgressCollection => Insite::ProgressCollection,
+    Watir::Quote => Insite::Quote,
+    Watir::QuoteCollection => Insite::QuoteCollection,
+    Watir::RadialGradient => Insite::RadialGradient,
+    Watir::RadialGradientCollection => Insite::RadialGradientCollection,
+    Watir::Radio => Insite::Radio,
+    Watir::RadioCollection => Insite::RadioCollection,
+    Watir::Rect => Insite::Rect,
+    Watir::RectCollection => Insite::RectCollection,
+    Watir::Row => Insite::Row,
+    Watir::RowCollection => Insite::RowCollection,
+    Watir::SVG => Insite::SVG,
+    Watir::SVGCollection => Insite::SVGCollection,
+    Watir::SVGElement => Insite::SVGElement,
+    Watir::SVGElementCollection => Insite::SVGElementCollection,
+    Watir::Script => Insite::Script,
+    Watir::ScriptCollection => Insite::ScriptCollection,
+    Watir::Select => Insite::Select,
+    Watir::SelectCollection => Insite::SelectCollection,
+    Watir::Solidcolor => Insite::Solidcolor,
+    Watir::SolidcolorCollection => Insite::SolidcolorCollection,
+    Watir::Source => Insite::Source,
+    Watir::SourceCollection => Insite::SourceCollection,
+    Watir::Span => Insite::Span,
+    Watir::SpanCollection => Insite::SpanCollection,
+    Watir::Stop => Insite::Stop,
+    Watir::StopCollection => Insite::StopCollection,
+    Watir::Style => Insite::Style,
+    Watir::StyleCollection => Insite::StyleCollection,
+    Watir::Switch => Insite::Switch,
+    Watir::SwitchCollection => Insite::SwitchCollection,
+    Watir::Symbol => Insite::Symbol,
+    Watir::SymbolCollection => Insite::SymbolCollection,
+    Watir::TSpan => Insite::TSpan,
+    Watir::TSpanCollection => Insite::TSpanCollection,
+    Watir::Table => Insite::Table,
+    Watir::TableCaption => Insite::TableCaption,
+    Watir::TableCaptionCollection => Insite::TableCaptionCollection,
+    Watir::TableCell => Insite::TableCell,
+    Watir::TableCellCollection => Insite::TableCellCollection,
+    Watir::TableCol => Insite::TableCol,
+    Watir::TableColCollection => Insite::TableColCollection,
+    Watir::TableCollection => Insite::TableCollection,
+    Watir::TableDataCell => Insite::TableDataCell,
+    Watir::TableDataCellCollection => Insite::TableDataCellCollection,
+    Watir::TableHeaderCell => Insite::TableHeaderCell,
+    Watir::TableHeaderCellCollection => Insite::TableHeaderCellCollection,
+    Watir::TableRow => Insite::TableRow,
+    Watir::TableRowCollection => Insite::TableRowCollection,
+    Watir::TableSection => Insite::TableSection,
+    Watir::TableSectionCollection => Insite::TableSectionCollection,
+    Watir::Template => Insite::Template,
+    Watir::TemplateCollection => Insite::TemplateCollection,
+    Watir::TextArea => Insite::TextArea,
+    Watir::TextAreaCollection => Insite::TextAreaCollection,
+    Watir::TextContent => Insite::TextContent,
+    Watir::TextContentCollection => Insite::TextContentCollection,
+    Watir::TextField => Insite::TextField,
+    Watir::TextFieldCollection => Insite::TextFieldCollection,
+    Watir::TextPath => Insite::TextPath,
+    Watir::TextPathCollection => Insite::TextPathCollection,
+    Watir::TextPositioning => Insite::TextPositioning,
+    Watir::TextPositioningCollection => Insite::TextPositioningCollection,
+    Watir::Time => Insite::Time,
+    Watir::TimeCollection => Insite::TimeCollection,
+    Watir::Title => Insite::Title,
+    Watir::TitleCollection => Insite::TitleCollection,
+    Watir::Track => Insite::Track,
+    Watir::TrackCollection => Insite::TrackCollection,
+    Watir::UList => Insite::UList,
+    Watir::UListCollection => Insite::UListCollection,
+    Watir::Unknown => Insite::Unknown,
+    Watir::UnknownCollection => Insite::UnknownCollection,
+    Watir::Use => Insite::Use,
+    Watir::UseCollection => Insite::UseCollection,
+    Watir::Video => Insite::Video,
+    Watir::VideoCollection => Insite::VideoCollection,
+    Watir::View => Insite::View,
+    Watir::ViewCollection => Insite::ViewCollection,
+  }.freeze
+end