pakyow-reflection 1.0.0.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 06a3fad2efdf75a2570eb8ec91fa74ea9cfe813fd7519de08c36ee85af4af4a7
+  data.tar.gz: 26e3f2526b1668dce5bef2d920597251c4d464e149ec69801415f17f6db2e8a7
+SHA512:
+  metadata.gz: caddc15fbd9aa77b7fef080db96b1d59bf9649ef57d55aed2d45556d067e2864a85c2f86b771ec8c55ed276639902baa5ce0bfc302ccb01c82c9b9437dc9e799
+  data.tar.gz: 7ba4c7c16c39f61af0ae09899ca6b1cf6e594bddc07a73da3721f3fe08d2220e3e9e6d9d01d691b2db8106ae785cadbf0f0688aa0230ba36e31b3511f9dc31d4

data/LICENSE

@@ -0,0 +1,4 @@
+Copyright (c) Metabahn, LLC
+
+Pakyow is an open-source project licensed under the terms of the LGPLv3 license.
+See <https://choosealicense.com/licenses/gpl-3.0/> for license text.

data/README.md

@@ -0,0 +1,29 @@
+# pakyow-reflection
+
+Reflected behavior for Pakyow.
+
+# Download
+
+The latest version of Pakyow Reflection can be installed with RubyGems:
+
+```
+gem install pakyow-reflection
+```
+
+Source code can be downloaded as part of the Pakyow project on Github:
+
+- https://github.com/pakyow/pakyow/tree/master/pakyow-reflection
+
+# License
+
+Pakyow Reflection is free and open-source under the [LGPLv3 license](https://choosealicense.com/licenses/gpl-3.0/).
+
+# Support
+
+Found a bug? Tell us about it here:
+
+- https://github.com/pakyow/pakyow/issues
+
+We'd love to have you in the community:
+
+- http://pakyow.org/get-involved

data/lib/pakyow/reflection/action.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "pakyow/support/inflector"
+
+module Pakyow
+  module Reflection
+    class Action
+      attr_reader :name, :scope, :node, :view_path, :binding, :attributes, :nested, :parents
+
+      def initialize(name:, scope:, node:, view_path:, binding: nil, attributes: [], nested: [], parents: [])
+        @name, @scope, @node, @view_path, @binding, @attributes, @nested, @parents = normalize(name), scope, node, view_path, binding, attributes, nested, parents
+      end
+
+      def named?(name)
+        @name == normalize(name)
+      end
+
+      private
+
+      def normalize(name)
+        Support.inflector.singularize(name.to_s).to_sym
+      end
+    end
+  end
+end

data/lib/pakyow/reflection/attribute.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "pakyow/support/inflector"
+
+module Pakyow
+  module Reflection
+    class Attribute
+      attr_reader :name, :type
+
+      def initialize(name, type:, required: false)
+        @name, @type, @required = normalize(name), type, required
+      end
+
+      def named?(name)
+        @name == normalize(name)
+      end
+
+      def required?
+        @required == true
+      end
+
+      private
+
+      def normalize(name)
+        name.to_s.to_sym
+      end
+    end
+  end
+end

data/lib/pakyow/reflection/behavior/config.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "pakyow/support/class_state"
+
+require "pakyow/reflection/builders/source"
+require "pakyow/reflection/builders/endpoints"
+require "pakyow/reflection/builders/actions"
+
+module Pakyow
+  module Reflection
+    module Behavior
+      module Config
+        extend Support::Extension
+
+        apply_extension do
+          configurable :reflection do
+            setting :builders, {
+              source: Builders::Source,
+              endpoints: Builders::Endpoints,
+              actions: Builders::Actions
+            }
+
+            setting :ignored_template_stores, [:errors]
+
+            configurable :data do
+              setting :connection, :default
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/reflection/behavior/reflecting.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "pakyow/support/class_state"
+
+require "pakyow/reflection/mirror"
+
+module Pakyow
+  module Reflection
+    module Behavior
+      module Reflecting
+        extend Support::Extension
+
+        apply_extension do
+          attr_reader :mirror
+
+          after "initialize", priority: :high do
+            @mirror = Mirror.new(self)
+
+            builders = Hash[
+              config.reflection.builders.map { |type, builder|
+                [type, builder.new(self, @mirror.scopes)]
+              }
+            ]
+
+            # Build the scopes.
+            #
+            @mirror.scopes.each do |scope|
+              builders[:source].build(scope)
+            end
+
+            # Build the actions.
+            #
+            @mirror.scopes.each do |scope|
+              builders[:actions].build(scope.actions)
+            end
+
+            # Build the endpoints.
+            #
+            builders[:endpoints].build(@mirror.endpoints)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/reflection/behavior/rendering/install_form_metadata.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "pakyow/support/extension"
+
+module Pakyow
+  module Reflection
+    module Behavior
+      module Rendering
+        module InstallFormMetadata
+          extend Support::Extension
+
+          apply_extension do
+            build do |view, composer:|
+              forms = view.forms
+              if !view.object.is_a?(StringDoc) && view.object.significant?(:form)
+                forms << view
+              end
+
+              forms.each do |form|
+                form.label(:form)[:view_path] = composer.view_path
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/reflection/builders/abstract.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pakyow
+  module Reflection
+    module Builders
+      class Abstract
+        def initialize(app, scopes)
+          @app, @scopes = app, scopes
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/reflection/builders/actions.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "pakyow/reflection/builders/abstract"
+require "pakyow/reflection/builders/helpers/controller"
+
+module Pakyow
+  module Reflection
+    module Builders
+      class Actions < Abstract
+        include Helpers::Controller
+
+        def build(actions)
+          actions.each do |action|
+            define_action(action)
+          end
+        end
+
+        private
+
+        def define_action(action)
+          if action.parents.any?
+            parents = action.parents.dup
+
+            current_resource = ensure_controller_has_helpers(
+              find_or_define_resource_for_scope_at_path(parents.shift, action.view_path)
+            )
+
+            parents.each do |parent|
+              current_resource = ensure_controller_has_helpers(
+                find_or_define_resource_for_scope_in_resource(parent, current_resource)
+              )
+            end
+
+            resource = find_or_define_resource_for_scope_in_resource(action.scope, current_resource)
+          else
+            resource = find_or_define_resource_for_scope_at_path(action.scope, action.view_path)
+          end
+
+          ensure_controller_has_helpers(resource)
+
+          # Define the route unless it exists.
+          #
+          # Actions are easy since they always go in the resource controller for
+          # the scope. If a nested scope, the action is defined on the nested
+          # resource returned by `find_or_define_resource_for_scope`.
+          #
+          route = resource.routes.values.flatten.find { |possible_route|
+            possible_route.name == action.name
+          } || resource.send(action.name) do
+            reflect
+          end
+
+          # Install the reflect action if it hasn't been installed for this route.
+          #
+          if route.name
+            unless action.node.labeled?(:endpoint)
+              form_endpoint_name = [resource.name_of_self.to_s, route.name.to_s].join("_").to_sym
+              action.node.significance << :endpoint
+              action.node.set_label(:endpoint, form_endpoint_name)
+              action.node.attributes[:"data-e"] = form_endpoint_name
+            end
+
+            resource.action :set_reflected_action, only: [route.name] do
+              if connection.form
+                form_view_path = connection.form[:view_path]
+                form_binding = connection.form[:binding]&.to_sym
+
+                connection.set(:__reflected_action, action.scope.actions.find { |possible_action|
+                  possible_action.view_path == form_view_path && possible_action.binding == form_binding
+                })
+              end
+            end
+          else
+            # TODO: warn the user that a reflection couldn't be installed for an unnamed route
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/reflection/builders/endpoints.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "pakyow/support/core_refinements/string/normalization"
+
+require "pakyow/reflection/builders/abstract"
+require "pakyow/reflection/builders/helpers/controller"
+require "pakyow/reflection/extensions/controller"
+
+module Pakyow
+  module Reflection
+    module Builders
+      class Endpoints < Abstract
+        include Helpers::Controller
+
+        using Support::Refinements::String::Normalization
+
+        def build(endpoints)
+          endpoints.each do |endpoint|
+            define_endpoint(endpoint)
+          end
+        end
+
+        private
+
+        def define_endpoint(endpoint)
+          controller = if within_resource?(endpoint.view_path)
+            find_or_define_resource_for_scope_at_path(
+              resource_source_at_path(endpoint.view_path),
+              controller_path(endpoint.view_path),
+              endpoint.type
+            )
+          else
+            find_or_define_controller_at_path(controller_path(endpoint.view_path))
+          end
+
+          # TODO: Make this the responsibility of the helpers.
+          #
+          ensure_controller_has_helpers(controller)
+
+          if controller.expansions.include?(:resource)
+            endpoint_name = String.normalize_path(
+              endpoint.view_path.gsub(String.collapse_path(controller.path_to_self), "")
+            ).split("/", 2)[1]
+
+            endpoint_name = if endpoint_name.empty?
+              :list
+            else
+              endpoint_name.to_sym
+            end
+
+            case endpoint_name
+            when :new, :edit, :list, :show
+              # Find or define the route by resource endpoint name.
+              #
+              route = controller.routes.values.flatten.find { |possible_route|
+                possible_route.name == endpoint_name
+              } || controller.send(endpoint_name) do
+                reflect
+              end
+            end
+          end
+
+          unless route
+            # Find or define the route by path.
+            #
+            # TODO: This should look across all controllers, not just the current one. Look through endpoints?
+            #
+            route = controller.routes.values.flatten.find { |possible_route|
+              possible_route.path == route_path(endpoint.view_path)
+            } || controller.get(route_name(endpoint.view_path), route_path(endpoint.view_path)) do
+              operations.reflect(controller: self)
+            end
+          end
+
+          if route.name
+            controller.action :set_reflected_endpoint, only: [route.name] do
+              connection.set(:__reflected_endpoint, endpoint)
+            end
+          else
+            # TODO: warn the user that a reflection couldn't be installed for an unnamed route
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/reflection/builders/helpers/controller.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require "pakyow/support/core_refinements/string/normalization"
+
+module Pakyow
+  module Reflection
+    module Builders
+      module Helpers
+        module Controller
+          using Support::Refinements::String::Normalization
+
+          def find_or_define_controller_at_path(path)
+            controller_at_path(path) || define_controller_at_path(path)
+          end
+
+          def controller_at_path(path, state = @app.state(:controller))
+            if state.any?
+              state.find { |controller|
+                String.normalize_path(String.collapse_path(controller.path_to_self)) == String.normalize_path(path)
+              } || controller_at_path(path, state.flat_map(&:children))
+            else
+              nil
+            end
+          end
+
+          def controller_closest_to_path(path, state = @app.state(:controller))
+            if state.any?
+              controller_closest_to_path(path, state.flat_map(&:children)) || state.find { |controller|
+                String.normalize_path(path).start_with?(String.normalize_path(String.collapse_path(controller.path_to_self)))
+              }
+            else
+              nil
+            end
+          end
+
+          def define_controller_at_path(path, within: nil)
+            nested_state = if within
+              within.children
+            else
+              @app.state(:controller)
+            end
+
+            path = String.normalize_path(path)
+
+            if controller = controller_closest_to_path(path, nested_state)
+              context = controller
+              path = path.gsub(
+                /^#{String.normalize_path(String.collapse_path(controller.path_to_self))}/, ""
+              )
+            else
+              context = within || @app
+            end
+
+            controller_name = if path == "/"
+              :root
+            else
+              String.normalize_path(path)[1..-1].gsub("/", "_").to_sym
+            end
+
+            method = if context.is_a?(Class) && context.ancestors.include?(Pakyow::Controller)
+              :namespace
+            else
+              :controller
+            end
+
+            context.send(method, controller_name, String.normalize_path(path)) do
+              # intentionally empty
+            end
+          end
+
+          def controller_path(view_path)
+            if view_path_directory?(view_path)
+              view_path
+            else
+              view_path.split("/")[0..-2].to_a.join("/")
+            end
+          end
+
+          def within_resource?(view_path)
+            view_path.split("/").any? { |view_path_part|
+              @app.state(:source).any? { |source|
+                source.plural_name == view_path_part.to_sym
+              }
+            }
+          end
+
+          def route_name(view_path)
+            if view_path_directory?(view_path)
+              :default
+            else
+              view_path.split("/").last.to_sym
+            end
+          end
+
+          def route_path(view_path)
+            if view_path_directory?(view_path)
+              "/"
+            else
+              "/#{view_path.split("/").last}"
+            end
+          end
+
+          def resource_source_at_path(view_path)
+            view_path.split("/").reverse.each do |view_path_part|
+              @app.state(:source).each do |source|
+                if source.plural_name == view_path_part.to_sym
+                  return source
+                end
+              end
+            end
+          end
+
+          def view_path_directory?(view_path)
+            @app.state(:templates).any? { |templates|
+              File.directory?(File.join(templates.path, templates.config[:paths][:pages], view_path))
+            }
+          end
+
+          RESOURCE_ENDPOINTS = %i(new edit list show).freeze
+
+          def find_or_define_resource_for_scope_at_path(scope, path, endpoint_type = nil)
+            resource = resource_for_scope_at_path(scope, path) || define_resource_for_scope_at_path(scope, path)
+
+            if path.end_with?(resource_path_for_scope(scope)) || endpoint_type.nil? || RESOURCE_ENDPOINTS.include?(path.split("/").last.to_sym)
+              return resource
+            else
+              controller_for_endpoint_type = resource.send(endpoint_type)
+
+              nested_path = if view_path_directory?(path)
+                path
+              else
+                path.split("/")[0..-2].join("/")
+              end
+
+              nested_path = nested_path.gsub(
+                /^#{String.normalize_path(String.collapse_path(controller_for_endpoint_type.path_to_self))}/, ""
+              )
+
+              if current_controller = controller_at_path(nested_path, resource.children)
+                return current_controller
+              else
+                if nested_path.empty?
+                  controller_for_endpoint_type
+                else
+                  define_controller_at_path(nested_path, within: controller_for_endpoint_type)
+                end
+              end
+            end
+          end
+
+          def resource_for_scope_at_path(scope, path, state = @app.state(:controller))
+            if state.any?
+              state.select { |controller|
+                controller.expansions.include?(:resource)
+              }.find { |controller|
+                String.normalize_path(String.collapse_path(controller.path_to_self)) == full_resource_path_for_scope_at_path(scope, path)
+              } || resource_for_scope_at_path(scope, path, state.flat_map(&:children))
+            else
+              nil
+            end
+          end
+
+          def define_resource_for_scope_at_path(scope, path)
+            context = if resource_namespace_path = resource_namespace_path_for_scope_at_path(scope, path)
+              if within_resource?(resource_namespace_path)
+                ensure_controller_has_helpers(
+                  find_or_define_resource_for_scope_at_path(
+                    resource_source_at_path(resource_namespace_path), resource_namespace_path
+                  )
+                )
+              else
+                ensure_controller_has_helpers(
+                  find_or_define_controller_at_path(resource_namespace_path)
+                )
+              end
+            else
+              @app
+            end
+
+            context.resource resource_name_for_scope(scope), resource_path_for_scope(scope) do
+              # intentionally empty
+            end
+          end
+
+          def resource_namespace_path_for_scope_at_path(scope, path)
+            resource_path = resource_path_for_scope(scope)
+
+            if path.start_with?(resource_path)
+              nil
+            elsif path.include?(resource_path)
+              path.split(resource_path, 2)[0]
+            end
+          end
+
+          def resource_name_for_scope(scope)
+            scope.plural_name
+          end
+
+          def resource_path_for_scope(scope)
+            String.normalize_path(scope.plural_name)
+          end
+
+          def ensure_controller_has_helpers(controller)
+            unless controller.ancestors.include?(Extension::Controller)
+              controller.include Extension::Controller
+            end
+
+            controller
+          end
+
+          def find_or_define_resource_for_scope_in_resource(scope, resource)
+            resource.children.find { |child|
+              child.path == resource_path_for_scope(scope)
+            } || resource.resource(resource_name_for_scope(scope), resource_path_for_scope(scope)) do
+              # intentionally empty
+            end
+          end
+
+          def full_resource_path_for_scope_at_path(scope, path)
+            String.normalize_path(
+              File.join(
+                resource_namespace_path_for_scope_at_path(scope, path).to_s,
+                scope.plural_name.to_s
+              )
+            )
+          end
+
+
+
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/reflection/builders/source.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "pakyow/reflection/builders/abstract"
+
+module Pakyow
+  module Reflection
+    module Builders
+      class Source < Abstract
+        def build(scope)
+          (source_for_scope(scope) || define_source_for_scope(scope)).class_eval do
+            scope.attributes.each do |attribute|
+              unless attributes.key?(attribute.name)
+                attribute attribute.name, attribute.type
+              end
+            end
+
+            scope.children.each do |child_scope|
+              unless associations[:has_many].any? { |association|
+                                                      association.name == child_scope.plural_name
+                                                    } || associations[:has_one].any? { |association|
+                                                      association.name == child_scope.name
+                                                    }
+                has_many child_scope.plural_name, dependent: :delete
+              end
+            end
+          end
+        end
+
+        private
+
+        def source_for_scope(scope)
+          @app.state(:source).find { |source|
+            source.plural_name == scope.plural_name
+          }
+        end
+
+        def define_source_for_scope(scope)
+          connection = if scope.actions.any?
+            @app.config.reflection.data.connection
+          else
+            :memory
+          end
+
+          @app.source scope.plural_name, adapter: :sql, connection: connection do
+            # intentionally empty
+          end
+        end
+      end
+    end
+  end
+end