pakyow-reflection 1.0.0.rc1

data/lib/pakyow/reflection/mirror.rb

@@ -0,0 +1,343 @@
+# frozen_string_literal: true
+
+require "pakyow/support/inflector"
+
+require "pakyow/presenter/composers/view"
+
+require "pakyow/reflection/action"
+require "pakyow/reflection/attribute"
+require "pakyow/reflection/endpoint"
+require "pakyow/reflection/nested"
+require "pakyow/reflection/scope"
+
+module Pakyow
+  module Reflection
+    # Reflects state from an application's view templates.
+    #
+    class Mirror
+      using Support::DeepDup
+
+      attr_reader :scopes, :endpoints, :actions
+
+      def initialize(app)
+        @app, @scopes, @endpoints, @actions = app, [], [], []
+
+        view_paths.each do |view_path|
+          discover_view_scopes(view_path: view_path)
+        end
+
+        view_paths.each do |view_path|
+          discover_view_path_associations(view_path: view_path)
+        end
+      end
+
+      def scope(name)
+        @scopes.find { |scope|
+          scope.named?(name)
+        }
+      end
+
+      private
+
+      def view_paths
+        @app.state(:templates).reject { |template_store|
+          @app.config.reflection.ignored_template_stores.include?(template_store.name)
+        }.flat_map(&:paths)
+      end
+
+      def discover_view_scopes(view_path:, view: nil, parent_scope: nil, parent_exposure: nil, binding_path: [])
+        unless view
+          composer = Presenter::Composers::View.new(view_path, app: @app)
+          view = composer.view(return_cached: true)
+        end
+
+        # Descend to find the most specific scope first.
+        #
+        view.each_binding_scope do |binding_scope_node|
+          unless binding_scope_node.significant?(:within_form) || binding_scope_node.labeled?(:plug)
+            binding_scope_view = Presenter::View.from_object(binding_scope_node)
+            scope = scope_for_binding(binding_scope_view.binding_name, parent_scope)
+
+            # Discover attributes from scopes nested within views.
+            #
+            discover_attributes(binding_scope_view, fields: false).each do |attribute|
+              unless scope.attribute(attribute.name, type: :view)
+                scope.add_attribute(attribute, type: :view)
+              end
+            end
+
+            # Define an endpoint for this scope.
+            #
+            endpoint = ensure_endpoint(
+              view_path, view.info.dig(:reflection, :endpoint)
+            )
+
+            unless endpoint.exposures.any? { |e| e.binding == binding_scope_view.channeled_binding_name}
+              exposure = Exposure.new(
+                scope: scope,
+                node: binding_scope_node,
+                parent: parent_exposure,
+                binding: binding_scope_view.channeled_binding_name,
+                dataset: binding_scope_view.label(:dataset)
+              )
+
+              endpoint.add_exposure(exposure)
+
+              # Discover nested view scopes.
+              #
+              discover_view_scopes(
+                view_path: view_path,
+                view: binding_scope_view,
+                parent_scope: scope,
+                parent_exposure: exposure,
+                binding_path: binding_path.dup << binding_scope_node.label(:binding)
+              )
+            end
+          end
+        end
+
+        # Discover forms.
+        #
+        view.object.each_significant_node(:form) do |form_node|
+          if form_node.labeled?(:binding)
+            form_view = Presenter::View.from_object(form_node)
+            scope = scope_for_binding(form_view.binding_name, parent_scope)
+
+            # Discover attributes from scopes nested within forms.
+            #
+            attributes = discover_attributes(form_view)
+            attributes.each do |attribute|
+              unless scope.attribute(attribute.name, type: :form)
+                scope.add_attribute(attribute, type: :form)
+              end
+            end
+
+            # Define an endpoint for this form.
+            #
+            endpoint = ensure_endpoint(
+              view_path, view.info.dig(:reflection, :endpoint)
+            )
+
+            unless endpoint.exposures.any? { |e| e.binding == form_view.channeled_binding_name }
+              exposure = Exposure.new(
+                scope: scope,
+                node: form_node,
+                parent: parent_exposure,
+                binding: form_view.channeled_binding_name
+              )
+
+              endpoint.add_exposure(exposure)
+
+              # Define the reflected action, if there is one.
+              #
+              if action = action_for_form(form_view, view_path)
+                # Define an action to handle this form submission.
+                #
+                scope.actions << Action.new(
+                  name: action,
+                  scope: scope,
+                  node: form_node,
+
+                  # We need the view path to to identify the correct action to pull
+                  # expected attributes from on submission.
+                  #
+                  view_path: view_path,
+
+                  # We need the channeled binding name to differentiate between submissions of two
+                  # forms with the same scope from the same view path.
+                  #
+                  binding: form_view.label(:channeled_binding),
+
+                  attributes: attributes,
+                  nested: discover_nested(form_view),
+                  parents: binding_path.map { |binding_path_part|
+                    scope(binding_path_part)
+                  }
+                )
+              end
+
+              # Discover nested form scopes.
+              discover_form_scopes(
+                view_path: view_path,
+                view: form_view,
+                parent_scope: scope,
+                parent_exposure: exposure
+              )
+            end
+          end
+        end
+
+        # Define delete actions for delete links.
+        #
+        view.object.find_significant_nodes(:endpoint).select { |endpoint_node|
+          endpoint_node.label(:endpoint).to_s.end_with?("_delete")
+        }.each do |endpoint_node|
+          scope = scope_for_binding(
+            endpoint_node.label(:endpoint).to_s.split("_", 2)[0],
+            parent_scope
+          )
+
+          unless scope.action(:delete)
+            scope.actions << Action.new(
+              name: :delete,
+              scope: scope,
+              node: endpoint_node,
+              view_path: view_path
+            )
+          end
+        end
+      end
+
+      def discover_view_path_associations(view_path:)
+        view_path_parts = view_path.split("/").reverse.map(&:to_sym)
+
+        until view_path_parts.count < 2
+          view_path_part = view_path_parts.shift
+
+          if child_scope = scope(view_path_part)
+            view_path_parts.map { |each_view_path_part|
+              scope(each_view_path_part)
+            }.compact.each do |parent_scope|
+              child_scope.add_parent(parent_scope)
+            end
+          end
+        end
+      end
+
+      def discover_form_scopes(view_path:, view: nil, parent_scope: nil, parent_exposure: nil)
+        view.each_binding_scope do |binding_scope_node|
+          if binding_scope_node.significant?(:field) || binding_scope_node.find_significant_nodes(:field).any?
+            binding_scope_view = Presenter::View.from_object(binding_scope_node)
+            scope = scope_for_binding(binding_scope_view.binding_name, parent_scope)
+
+            # Discover attributes from scopes nested within forms.
+            #
+            discover_attributes(binding_scope_view).each do |attribute|
+              unless scope.attribute(attribute.name, type: :form)
+                scope.add_attribute(attribute, type: :form)
+              end
+            end
+
+            # Discover nested form scopes.
+            #
+            discover_form_scopes(
+              view_path: view_path,
+              view: binding_scope_view,
+              parent_scope: scope
+            )
+          end
+        end
+      end
+
+      IGNORED_ATTRIBUTES = %i(id).freeze
+
+      def discover_attributes(view, fields: true)
+        view.binding_props.reject { |binding_prop_node|
+          binding_prop_node.significant?(:multipart_binding) && binding_prop_node.label(:binding) != view.binding_name
+        }.select { |binding_prop_node|
+          !fields || Presenter::Form::FIELD_TAGS.include?(binding_prop_node.tagname)
+        }.each_with_object([]) do |binding_prop_node, attributes|
+          binding_prop_view = Presenter::View.from_object(binding_prop_node)
+          binding_prop_name = if binding_prop_node.significant?(:multipart_binding)
+            binding_prop_node.label(:binding_prop)
+          else
+            binding_prop_node.label(:binding)
+          end
+
+          unless IGNORED_ATTRIBUTES.include?(binding_prop_name)
+            attribute = Attribute.new(
+              binding_prop_name,
+              type: type_for_form_view(binding_prop_view),
+              required: binding_prop_view.attrs.has?(:required)
+            )
+
+            attributes << attribute
+          end
+        end
+      end
+
+      def discover_nested(view)
+        view.binding_scopes.select { |binding_scope_node|
+          binding_scope_node.significant?(:field) || binding_scope_node.find_significant_nodes(:field).any?
+        }.map { |binding_scope_node|
+          binding_scope_view = Presenter::View.from_object(binding_scope_node)
+
+          Nested.new(
+            binding_scope_view.binding_name,
+            attributes: discover_attributes(binding_scope_view),
+            nested: discover_nested(binding_scope_view)
+          )
+        }
+      end
+
+      def scope_for_binding(binding, parent_scope)
+        unless scope = scopes.find { |possible_scope| possible_scope.named?(binding) }
+          scope = Scope.new(binding); @scopes << scope
+        end
+
+        if parent_scope
+          scope.add_parent(parent_scope)
+        end
+
+        scope
+      end
+
+      def type_for_form_view(view)
+        type_for_binding_name(view.binding_name.to_s) ||
+        (view.attributes.has?(:type) && type_for_attribute_type(view.attributes[:type])) ||
+        :string
+      end
+
+      def type_for_binding_name(binding_name)
+        if binding_name.end_with?("_at")
+          :datetime
+        else
+        end
+      end
+
+      def type_for_attribute_type(type)
+        case type
+        when "date"
+          :date
+        when "time"
+          :time
+        when "datetime-local"
+          :datetime
+        when "number", "range"
+          :decimal
+        else
+          nil
+        end
+      end
+
+      def action_for_form(view, path)
+        plural_binding_name = Support.inflector.pluralize(view.binding_name)
+        if view.labeled?(:endpoint)
+          endpoint = view.label(:endpoint).to_s
+          if endpoint.end_with?("#{plural_binding_name}_create")
+            :create
+          elsif endpoint.end_with?("#{plural_binding_name}_update")
+            :update
+          elsif endpoint.end_with?("#{plural_binding_name}_delete")
+            :delete
+          else
+            nil
+          end
+        elsif path.include?(plural_binding_name) && path.include?("edit")
+          :update
+        else
+          :create
+        end
+      end
+
+      def ensure_endpoint(view_path, options)
+        unless endpoint = @endpoints.find { |e| e.view_path == view_path }
+          endpoint = Endpoint.new(view_path, options: options)
+          @endpoints << endpoint
+        end
+
+        endpoint
+      end
+    end
+  end
+end

data/lib/pakyow/reflection/nested.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "pakyow/support/inflector"
+
+module Pakyow
+  module Reflection
+    class Nested
+      attr_reader :name, :attributes, :nested
+
+      def initialize(name, attributes: [], nested: [])
+        @name, @attributes, @nested = normalize(name), attributes, nested
+      end
+
+      def named?(name)
+        @name == normalize(name)
+      end
+
+      def plural_name
+        Support.inflector.pluralize(@name).to_sym
+      end
+
+      private
+
+      def normalize(name)
+        name.to_s.to_sym
+      end
+    end
+  end
+end

data/lib/pakyow/reflection/scope.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "pakyow/support/inflector"
+
+module Pakyow
+  module Reflection
+    class Scope
+      attr_reader :name, :parents, :actions, :children
+      attr_writer :parent
+
+      def initialize(name)
+        @name = normalize(name)
+        @parents, @actions, @attributes, @children = [], [], { form: [], view: [] }, []
+      end
+
+      def add_parent(parent)
+        unless @parents.include?(parent)
+          @parents << parent
+          parent.children << self
+        end
+      end
+
+      def named?(name)
+        @name == normalize(name)
+      end
+
+      def action(name)
+        @actions.find { |action|
+          action.named?(name)
+        }
+      end
+
+      def attribute(name, type:)
+        @attributes[type].find { |attribute|
+          attribute.named?(name)
+        }
+      end
+
+      def add_attribute(attribute, type:)
+        @attributes[type] << attribute
+      end
+
+      def attributes
+        # TODO: In addition to finding view attributes, should we be finding view associations?
+        #
+        @attributes[:form].concat(@attributes[:view]).uniq { |attribute|
+          attribute.name
+        }
+      end
+
+      def plural_name
+        Support.inflector.pluralize(@name).to_sym
+      end
+
+      private
+
+      def normalize(name)
+        Support.inflector.singularize(name.to_s).to_sym
+      end
+    end
+  end
+end

data/lib/pakyow/reflection.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "pakyow/routing"
+require "pakyow/presenter"
+
+# Load data after presenter, so that containers are created with reflected attributes.
+#
+require "pakyow/data"
+
+require "pakyow/form"
+
+require "pakyow/reflection/framework"

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: pakyow-reflection
+version: !ruby/object:Gem::Version
+  version: 1.0.0.rc1
+platform: ruby
+authors:
+- Bryan Powell
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-07-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pakyow-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.rc1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.rc1
+- !ruby/object:Gem::Dependency
+  name: pakyow-data
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.rc1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.rc1
+- !ruby/object:Gem::Dependency
+  name: pakyow-form
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.rc1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.rc1
+- !ruby/object:Gem::Dependency
+  name: pakyow-presenter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.rc1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.rc1
+- !ruby/object:Gem::Dependency
+  name: pakyow-support
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.rc1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.rc1
+description: Reflected behavior for Pakyow
+email: bryan@metabahn.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/pakyow/reflection.rb
+- lib/pakyow/reflection/action.rb
+- lib/pakyow/reflection/attribute.rb
+- lib/pakyow/reflection/behavior/config.rb
+- lib/pakyow/reflection/behavior/reflecting.rb
+- lib/pakyow/reflection/behavior/rendering/install_form_metadata.rb
+- lib/pakyow/reflection/builders/abstract.rb
+- lib/pakyow/reflection/builders/actions.rb
+- lib/pakyow/reflection/builders/endpoints.rb
+- lib/pakyow/reflection/builders/helpers/controller.rb
+- lib/pakyow/reflection/builders/source.rb
+- lib/pakyow/reflection/endpoint.rb
+- lib/pakyow/reflection/extensions/controller.rb
+- lib/pakyow/reflection/framework.rb
+- lib/pakyow/reflection/mirror.rb
+- lib/pakyow/reflection/nested.rb
+- lib/pakyow/reflection/scope.rb
+homepage: https://pakyow.org
+licenses:
+- LGPL-3.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Pakyow Reflection
+test_files: []