Class: PageEz::Page

Inherits:
Object
  • Object
show all
Defined in:
lib/page_ez/page.rb

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(container = nil) ⇒ Page

Returns a new instance of Page.



45
46
47
48
49
 
# File 'lib/page_ez/page.rb', line 45

def initialize(container = nil)
  @container = container || Class.new do
    include Capybara::DSL
  end.new
end

Class Method Details

.base_selector(value) ⇒ Object 



26
27
28
 
# File 'lib/page_ez/page.rb', line 26

def self.base_selector(value)
  self.container_base_selector = value
end

.constructor_from_block(superclass = nil, &block) ⇒ Object 



138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
 
# File 'lib/page_ez/page.rb', line 138

def self.constructor_from_block(superclass = nil, &block)
  if block
    self.nested_macro = true
    Class.new(superclass || self).tap do |klass|
      visitor.begin_block_evaluation
      klass.macro_registrar = {}
      klass.container_base_selector = nil
      klass.class_eval(&block)
      visitor.end_block_evaluation
      self.nested_macro = false
    end
  elsif superclass
    superclass
  else
    Class.new(BasicObject) do
      def self.new(value)
        value
      end
    end
  end
end

.contains(page_object, only: nil) ⇒ Object 



30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/page_ez/page.rb', line 30

def self.contains(page_object, only: nil)
  delegation_target = :"__page_object_#{page_object.object_id}__"

  has_one(delegation_target, page_object)

  if only
    methods_delegated_that_do_not_exist = only - page_object.instance_methods(false)
    if methods_delegated_that_do_not_exist.any?
      raise NoMethodError, "Attempting to delegate non-existent method(s) to #{page_object}: #{methods_delegated_that_do_not_exist.join(", ")}"
    end
  end

  delegate(*(only || page_object.instance_methods(false)), to: delegation_target)
end

.delegate ⇒ Object 



59
60
61
62
63
64
65
 
# File 'lib/page_ez/page.rb', line 59

def self.delegate(...)
  super.tap do |method_names|
    method_names.each do |method_name|
      visitor.track_method_delegated(method_name)
    end
  end
end

.has_many(name, *args, **options, &block) ⇒ Object 



96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
 
# File 'lib/page_ez/page.rb', line 96

def self.has_many(name, *args, **options, &block)
  construction_strategy = case [args.length, args.first]
  in [2, _] then
    MethodGenerators::HasManyStaticSelector.new(name, args.first.to_s, args[1], options, &block)
  in [1, String] | [1, Symbol] then
    MethodGenerators::HasManyStaticSelector.new(name, args.first.to_s, nil, options, &block)
  in [0, _] then
    MethodGenerators::HasManyDynamicSelector.new(name, options, &block)
  end

  visitor.process_macro(:has_many, name, construction_strategy)

  construction_strategy.run(self)

  self.macro_registrar = macro_registrar.merge(name => construction_strategy)
end

.has_many_ordered(name, *args, **options, &block) ⇒ Object 



113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
 
# File 'lib/page_ez/page.rb', line 113

def self.has_many_ordered(name, *args, **options, &block)
  construction_strategy = case [args.length, args.first]
  in [2, _] then
    MethodGenerators::HasManyOrderedSelector.new(name, args.first.to_s, args[1], options, &block)
  in [1, String] | [1, Symbol] then
    MethodGenerators::HasManyOrderedSelector.new(name, args.first.to_s, nil, options, &block)
  in [0, _] then
    MethodGenerators::HasManyOrderedDynamicSelector.new(name, options, &block)
  end

  visitor.process_macro(:has_many_ordered, name, construction_strategy)

  construction_strategy.run(self)

  self.macro_registrar = macro_registrar.merge(name => construction_strategy)
end

.has_one(name, *args, **options, &block) ⇒ Object 



77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
 
# File 'lib/page_ez/page.rb', line 77

def self.has_one(name, *args, **options, &block)
  construction_strategy = case [args.length, args.first]
  in [2, _] then
    MethodGenerators::HasOneStaticSelector.new(name, args.first.to_s, args[1], options, &block)
  in [1, Class] then
    MethodGenerators::HasOneComposedClass.new(name, args.first, options, &block)
  in [1, String] | [1, Symbol] then
    MethodGenerators::HasOneStaticSelector.new(name, args.first.to_s, nil, options, &block)
  in [0, _] then
    MethodGenerators::HasOneDynamicSelector.new(name, options, &block)
  end

  visitor.process_macro(:has_one, name, construction_strategy)

  construction_strategy.run(self)

  self.macro_registrar = macro_registrar.merge(name => construction_strategy)
end

.inherited(subclass) ⇒ Object 



130
131
132
133
134
135
136
 
# File 'lib/page_ez/page.rb', line 130

def self.inherited(subclass)
  if !nested_macro
    visitor.reset
  end

  visitor.inherit_from(subclass)
end

.logged_define_method(name, &block) ⇒ Object 



160
161
162
163
 
# File 'lib/page_ez/page.rb', line 160

def self.logged_define_method(name, &block)
  visitor.define_method(name)
  define_method(name, &block)
end

.method_added(name) ⇒ Object 



51
52
53
54
55
56
57
 
# File 'lib/page_ez/page.rb', line 51

def self.method_added(name)
  visitor.track_method_added(name, macro_registrar[name])

  if macro_registrar.key?(name)
    macro_registrar[name].run(self)
  end
end

.method_undefined(name) ⇒ Object 



67
68
69
 
# File 'lib/page_ez/page.rb', line 67

def self.method_undefined(name)
  visitor.track_method_undefined(name)
end

.rename_method(from:, to:) ⇒ Object 



71
72
73
74
75
 
# File 'lib/page_ez/page.rb', line 71

def self.rename_method(from:, to:)
  alias_method to, from
  undef_method from
  visitor.track_method_renamed(from, to)
end

Instance Method Details

#container ⇒ Object 



18
19
20
21
22
23
24
 
# File 'lib/page_ez/page.rb', line 18

def container
  if container_base_selector
    @container.find(container_base_selector)
  else
    @container
  end
end