page_ez 0.1.0

data/lib/page_ez/has_one_result.rb

@@ -0,0 +1,14 @@
+module PageEz
+  class HasOneResult
+    include DelegatesTo[:@result]
+
+    def initialize(container:, selector:, options:, constructor:)
+      @result = constructor.call(
+        container.find(
+          selector,
+          **options
+        )
+      )
+    end
+  end
+end

data/lib/page_ez/method_generators/define_has_many_result_methods.rb

@@ -0,0 +1,48 @@
+require_relative "identity_processor"
+
+module PageEz
+  module MethodGenerators
+    class DefineHasManyResultMethods
+      def initialize(name, evaluator_class:, constructor:, processor: IdentityProcessor)
+        @name = name
+        @evaluator_class = evaluator_class
+        @constructor = constructor
+        @processor = processor
+      end
+
+      def run(target)
+        name = @name
+        evaluator_class = @evaluator_class
+        constructor = @constructor
+        processor = @processor
+
+        target.logged_define_method(name) do |*args|
+          evaluator = evaluator_class.run(processor.run_args(args), target: self)
+
+          selector = processor.selector(evaluator.selector, args)
+
+          PageEz.reraise_selector_error(selector) do
+            PageEz::HasManyResult.new(
+              container: container,
+              selector: selector,
+              options: evaluator.options,
+              constructor: constructor.method(:new)
+            )
+          end
+        end
+
+        target.logged_define_method("has_#{name}_count?") do |count, *args|
+          send(name, *args).has_count_of?(count)
+        end
+
+        target.logged_define_method("has_#{name}?") do |*args|
+          send(name, *args).has_any_elements?
+        end
+
+        target.logged_define_method("has_no_#{name}?") do |*args|
+          send(name, *args).has_no_elements?
+        end
+      end
+    end
+  end
+end

data/lib/page_ez/method_generators/define_has_one_predicate_methods.rb

@@ -0,0 +1,42 @@
+module PageEz
+  module MethodGenerators
+    class DefineHasOnePredicateMethods
+      def initialize(name, evaluator_class:, processor: IdentityProcessor)
+        @name = name
+        @evaluator_class = evaluator_class
+        @processor = processor
+      end
+
+      def run(target)
+        evaluator_class = @evaluator_class
+        processor = @processor
+
+        target.logged_define_method("has_#{@name}?") do |*args|
+          evaluator = evaluator_class.run(processor.run_args(args), target: self)
+
+          selector = processor.selector(evaluator.selector, args)
+
+          PageEz.reraise_selector_error(selector) do
+            has_css?(
+              selector,
+              **evaluator.options
+            )
+          end
+        end
+
+        target.logged_define_method("has_no_#{@name}?") do |*args|
+          evaluator = evaluator_class.run(processor.run_args(args), target: self)
+
+          selector = processor.selector(evaluator.selector, args)
+
+          PageEz.reraise_selector_error(selector) do
+            has_no_css?(
+              selector,
+              **evaluator.options
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/page_ez/method_generators/define_has_one_result_methods.rb

@@ -0,0 +1,35 @@
+require_relative "identity_processor"
+
+module PageEz
+  module MethodGenerators
+    class DefineHasOneResultMethods
+      def initialize(name, evaluator_class:, constructor:, processor: IdentityProcessor)
+        @name = name
+        @evaluator_class = evaluator_class
+        @processor = processor
+        @constructor = constructor
+      end
+
+      def run(target)
+        evaluator_class = @evaluator_class
+        processor = @processor
+        constructor = @constructor
+
+        target.logged_define_method(@name) do |*args|
+          evaluator = evaluator_class.run(processor.run_args(args), target: self)
+
+          selector = processor.selector(evaluator.selector, args)
+
+          PageEz.reraise_selector_error(selector) do
+            PageEz::HasOneResult.new(
+              container: container,
+              selector: selector,
+              options: evaluator.options,
+              constructor: constructor.method(:new)
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/page_ez/method_generators/has_many_dynamic_selector.rb

@@ -0,0 +1,39 @@
+module PageEz
+  module MethodGenerators
+    class HasManyDynamicSelector
+      attr_reader :selector
+
+      def initialize(name, options, &block)
+        @run = false
+        @name = name
+        @options = options
+        @block = block
+      end
+
+      def run(target)
+        return if run?
+
+        if target.method_defined?(@name)
+          target.rename_method from: @name, to: :"_#{@name}"
+          @run = true
+
+          @selector = target.instance_method(:"_#{@name}")
+        else
+          @selector = @name.to_s
+        end
+
+        HasManyStaticSelector.new(@name, @selector, nil, @options, &@block).run(target)
+      end
+
+      def selector_type
+        :dynamic
+      end
+
+      private
+
+      def run?
+        @run
+      end
+    end
+  end
+end

data/lib/page_ez/method_generators/has_many_ordered_dynamic_selector.rb

@@ -0,0 +1,39 @@
+module PageEz
+  module MethodGenerators
+    class HasManyOrderedDynamicSelector
+      attr_reader :selector
+
+      def initialize(name, options, &block)
+        @run = false
+        @name = name
+        @options = options
+        @block = block
+      end
+
+      def run(target)
+        return if run?
+
+        if target.method_defined?(@name)
+          target.rename_method from: @name, to: :"_#{@name}"
+          @run = true
+
+          @selector = target.instance_method(:"_#{@name}")
+        else
+          @selector = @name.to_s
+        end
+
+        HasManyOrderedSelector.new(@name, @selector, nil, @options, &@block).run(target)
+      end
+
+      def selector_type
+        :dynamic
+      end
+
+      private
+
+      def run?
+        @run
+      end
+    end
+  end
+end

data/lib/page_ez/method_generators/has_many_ordered_selector.rb

@@ -0,0 +1,47 @@
+module PageEz
+  module MethodGenerators
+    class HasManyOrderedSelector
+      attr_reader :selector
+
+      def initialize(name, selector, dynamic_options, options, &block)
+        @name = name
+        @selector = selector
+        @core_selector = HasManyStaticSelector.new(name, selector, dynamic_options, options, &block)
+        @evaluator_class = SelectorEvaluator.build(@name, dynamic_options: dynamic_options, options: options, selector: selector)
+      end
+
+      def run(target)
+        singularized_name = Pluralization.new(@name).singularize
+
+        constructor = @core_selector.run(target)
+
+        DefineHasOneResultMethods.new(
+          "#{singularized_name}_at",
+          evaluator_class: @evaluator_class,
+          constructor: constructor,
+          processor: IndexedProcessor
+        ).run(target)
+
+        DefineHasOnePredicateMethods.new(
+          "#{singularized_name}_at",
+          evaluator_class: @evaluator_class,
+          processor: IndexedProcessor
+        ).run(target)
+      end
+
+      def selector_type
+        @core_selector.selector_type
+      end
+
+      class IndexedProcessor
+        def self.run_args(args)
+          args[1..]
+        end
+
+        def self.selector(selector, args)
+          "#{selector}:nth-of-type(#{args[0] + 1})"
+        end
+      end
+    end
+  end
+end

data/lib/page_ez/method_generators/has_many_static_selector.rb

@@ -0,0 +1,41 @@
+module PageEz
+  module MethodGenerators
+    class HasManyStaticSelector
+      attr_reader :selector
+
+      def initialize(name, selector, dynamic_options, options, &block)
+        @name = name
+        @selector = selector
+        @block = block
+        @evaluator_class = SelectorEvaluator.build(name, dynamic_options: dynamic_options, options: options, selector: selector)
+      end
+
+      def run(target)
+        target.constructor_from_block(&@block).tap do |constructor|
+          DefineHasManyResultMethods.new(
+            @name,
+            evaluator_class: @evaluator_class,
+            constructor: constructor
+          ).run(target)
+
+          singularized_name = Pluralization.new(@name).singularize
+
+          DefineHasOneResultMethods.new(
+            "#{singularized_name}_matching",
+            evaluator_class: @evaluator_class,
+            constructor: constructor
+          ).run(target)
+
+          DefineHasOnePredicateMethods.new(
+            "#{singularized_name}_matching",
+            evaluator_class: @evaluator_class
+          ).run(target)
+        end
+      end
+
+      def selector_type
+        :static
+      end
+    end
+  end
+end

data/lib/page_ez/method_generators/has_one_composed_class.rb

@@ -0,0 +1,40 @@
+module PageEz
+  module MethodGenerators
+    class HasOneComposedClass
+      attr_reader :selector
+
+      def initialize(name, composed_class, options, &block)
+        @name = name
+        @composed_class = composed_class
+        @options = options
+        @block = block
+      end
+
+      def run(target)
+        constructor = target.constructor_from_block(@composed_class, &@block)
+
+        base_selector = @options.delete(:base_selector)
+
+        target.logged_define_method(@name) do |*args|
+          if base_selector
+            Class.new(constructor).tap do |new_constructor|
+              new_constructor.base_selector base_selector
+            end.new(self)
+          else
+            constructor.new(self)
+          end
+        end
+
+        if base_selector
+          evaluator_class = SelectorEvaluator.build(
+            @name,
+            dynamic_options: nil,
+            options: @options,
+            selector: base_selector
+          )
+          DefineHasOnePredicateMethods.new(@name, evaluator_class: evaluator_class).run(target)
+        end
+      end
+    end
+  end
+end

data/lib/page_ez/method_generators/has_one_dynamic_selector.rb

@@ -0,0 +1,39 @@
+module PageEz
+  module MethodGenerators
+    class HasOneDynamicSelector
+      attr_reader :selector
+
+      def initialize(name, options, &block)
+        @run = false
+        @name = name
+        @options = options
+        @block = block
+      end
+
+      def run(target)
+        return if run?
+
+        if target.method_defined?(@name)
+          target.rename_method from: @name, to: :"_#{@name}"
+          @run = true
+
+          @selector = target.instance_method(:"_#{@name}")
+        else
+          @selector = @name.to_s
+        end
+
+        HasOneStaticSelector.new(@name, @selector, nil, @options, &@block).run(target)
+      end
+
+      def selector_type
+        :dynamic
+      end
+
+      private
+
+      def run?
+        @run
+      end
+    end
+  end
+end

data/lib/page_ez/method_generators/has_one_static_selector.rb

@@ -0,0 +1,25 @@
+module PageEz
+  module MethodGenerators
+    class HasOneStaticSelector
+      attr_reader :selector
+
+      def initialize(name, selector, dynamic_options, options, &block)
+        @name = name
+        @selector = selector
+        @evaluator_class = SelectorEvaluator.build(name, dynamic_options: dynamic_options, options: options, selector: selector)
+        @block = block
+      end
+
+      def run(target)
+        constructor = target.constructor_from_block(&@block)
+
+        DefineHasOneResultMethods.new(@name, evaluator_class: @evaluator_class, constructor: constructor).run(target)
+        DefineHasOnePredicateMethods.new(@name, evaluator_class: @evaluator_class).run(target)
+      end
+
+      def selector_type
+        :static
+      end
+    end
+  end
+end

data/lib/page_ez/method_generators/identity_processor.rb

@@ -0,0 +1,11 @@
+module PageEz::MethodGenerators
+  class IdentityProcessor
+    def self.run_args(args)
+      args
+    end
+
+    def self.selector(value, _)
+      value
+    end
+  end
+end

data/lib/page_ez/null_logger.rb

@@ -0,0 +1,12 @@
+module PageEz
+  class NullLogger
+    def debug(*)
+    end
+
+    def info(*)
+    end
+
+    def warn(*)
+    end
+  end
+end

data/lib/page_ez/options.rb

@@ -0,0 +1,37 @@
+require "active_support/core_ext/hash/keys"
+
+module PageEz
+  class Options
+    def self.merge(options, dynamic_options = nil, *args)
+      dynamic_options ||= -> { {} }
+
+      keys_to_extract = dynamic_options.parameters.filter_map do |type, name|
+        if type == :keyreq || type == :key
+          name
+        end
+      end
+
+      if args.last.is_a?(Hash)
+        if dynamic_options.arity == 0
+          options.merge(*args)
+        else
+          kwargs = args.pop
+
+          if keys_to_extract.empty?
+            options.merge(dynamic_options.call(*args, **kwargs))
+          else
+            sliced = kwargs.slice(*keys_to_extract)
+            except = kwargs.except(*keys_to_extract)
+            options.merge(
+              dynamic_options.call(*args, **sliced)
+            ).merge(
+              except
+            )
+          end
+        end
+      else
+        options.merge(dynamic_options.call(*args))
+      end
+    end
+  end
+end

data/lib/page_ez/page.rb

@@ -0,0 +1,162 @@
+require "capybara/dsl"
+require "active_support/core_ext/class/attribute"
+require "active_support/core_ext/module/delegation"
+
+module PageEz
+  class Page
+    include DelegatesTo[:container]
+    class_attribute :visitor, :macro_registrar, :nested_macro, :container_base_selector
+
+    self.visitor = PageVisitor.new
+    self.macro_registrar = {}
+    self.nested_macro = false
+    self.container_base_selector = nil
+
+    undef_method :select
+
+    def container
+      if container_base_selector
+        @container.find(container_base_selector)
+      else
+        @container
+      end
+    end
+
+    def self.base_selector(value)
+      self.container_base_selector = value
+    end
+
+    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
+
+    def initialize(container = nil)
+      @container = container || Class.new do
+        include Capybara::DSL
+      end.new
+    end
+
+    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
+
+    def self.delegate(...)
+      super(...).tap do |method_names|
+        method_names.each do |method_name|
+          visitor.track_method_delegated(method_name)
+        end
+      end
+    end
+
+    def self.method_undefined(name)
+      visitor.track_method_undefined(name)
+    end
+
+    def self.rename_method(from:, to:)
+      alias_method to, from
+      undef_method from
+      visitor.track_method_renamed(from, to)
+    end
+
+    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
+
+    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
+
+    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
+
+    def self.inherited(subclass)
+      if !nested_macro
+        visitor.reset
+      end
+
+      visitor.inherit_from(subclass)
+    end
+
+    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.class_eval(&block)
+          visitor.end_block_evaluation
+        end
+      elsif superclass
+        superclass
+      else
+        Class.new(BasicObject) do
+          def self.new(value)
+            value
+          end
+        end
+      end
+    end
+
+    def self.logged_define_method(name, &block)
+      visitor.define_method(name)
+      define_method(name, &block)
+    end
+  end
+end