linked_rails 0.0.1

data/app/models/linked_rails/form/field_factory.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class Form
+    class FieldFactory # rubocop:disable Metrics/ClassLength
+      MAX_STR_LEN = 255
+      VALIDATOR_SELECTORS = [
+        [:min_length, ActiveModel::Validations::LengthValidator, :minimum],
+        [:max_length, ActiveModel::Validations::LengthValidator, :maximum],
+        [:pattern, ActiveModel::Validations::FormatValidator, :with],
+        [:presence, ActiveModel::Validations::PresenceValidator, nil],
+        [:sh_in, ActiveModel::Validations::InclusionValidator, :in]
+      ].freeze
+      include ActiveModel::Model
+
+      attr_accessor :field_options, :form, :key
+
+      delegate :form_options_iri,
+               :model_class,
+               :model_policy!,
+               :serializer_attributes,
+               :serializer_class,
+               :serializer_reflections,
+               to: :form
+
+      def condition_or_field
+        @condition_or_field ||= model_policy!.condition_for(
+          key,
+          field,
+          property: field_options[:if] || [],
+          sh_not: field_options[:unless] || []
+        )
+      end
+
+      private
+
+      def attr_column(name)
+        column_model =
+          if model_class.is_delegated_attribute?(name)
+            model_class.class_for_delegated_attribute(name)
+          else
+            model_class
+          end
+        column_model.column_for_attribute(name)
+      end
+
+      def attr_to_datatype # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+        name = serializer_attribute&.key&.to_s || key.to_s
+        case attribute_type(name)
+        when :string, :text
+          Vocab.xsd.string
+        when :integer
+          Vocab.xsd.integer
+        when :datetime
+          Vocab.xsd.dateTime
+        when :date
+          Vocab.xsd.date
+        when :boolean
+          Vocab.xsd.boolean
+        when :decimal
+          decimal_data_type(name)
+        when :file
+          Vocab.ll[:blob]
+        else
+          Vocab.xsd.string if model_class.try(:defined_enums)&.key?(name)
+        end
+      end
+
+      def attribute_type(name)
+        model_class.try(:attribute_types).try(:[], name)&.type
+      rescue PG::ConnectionBad, ActiveRecord::StatementInvalid, ActiveRecord::ConnectionNotEstablished
+        :string
+      end
+
+      def attribute_validators
+        @attribute_validators ||= model_class.validators.select { |v| v.attributes.include?(model_attribute) }
+      end
+
+      def datatype
+        @datatype ||= field_options[:datatype] ||
+          serializer_attribute.try(:datatype) ||
+          (serializer_enum ? Vocab.xsd.string : attr_to_datatype)
+      end
+
+      def decimal_data_type(name) # rubocop:disable Metrics/MethodLength
+        case attr_column(name).precision
+        when 64
+          Vocab.xsd.long
+        when 32
+          Vocab.xsd.int
+        when 16
+          Vocab.xsd.short
+        when 8
+          Vocab.xsd.byte
+        else
+          Vocab.xsd.decimal
+        end
+      end
+
+      def field
+        field_class.new(field_attributes)
+      end
+
+      def field_attributes # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        return @field_attributes if @field_attributes
+
+        opts = field_options.except(:if, :unless)
+        opts[:form] = form
+        opts[:nested_form] = field_options[:form] if field_options.key?(:form)
+        opts[:model_class] = model_class
+        opts[:model_attribute] = model_attribute
+        opts[:key] = key
+        opts[:validators] ||= validators
+        opts[:path] ||= serializer_attribute&.predicate
+        opts[:datatype] ||= datatype
+        opts[:max_count] ||= 1
+        opts[:sh_in] = form_options_iri(serializer_attribute.key.to_s) if serializer_enum && !opts[:sh_in]
+
+        @field_attributes = opts
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      def field_class
+        return field_attributes[:input_field] if field_attributes.key?(:input_field)
+        return max_count > 1 ? Form::Field::CheckboxGroup : Form::Field::SelectInput if sh_in
+        return Form::Field::SliderInput if max_inclusive && min_inclusive
+
+        case datatype
+        when Vocab.xsd.boolean
+          return Form::Field::CheckboxInput
+        when Vocab.xsd.date
+          return Form::Field::DateInput
+        when Vocab.xsd.dateTime
+          return Form::Field::DateTimeInput
+        when Vocab.xsd.integer, Vocab.xsd.long, Vocab.xsd.int, Vocab.xsd.short, Vocab.xsd.byte, Vocab.xsd.decimal
+          return Form::Field::NumberInput
+        when Vocab.ll.blob
+          return Form::Field::FileInput
+        when Vocab.fhir.markdown
+          return Form::Field::MarkdownInput
+        when Vocab.ontola['datatype/password']
+          return Form::Field::PasswordInput
+        when Vocab.ontola['datatype/postalRange']
+          return Form::Field::PostalRangeInput
+        else
+          max_length && max_length > MAX_STR_LEN ? Form::Field::TextAreaInput : Form::Field::TextInput
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+      def max_count
+        field_attributes[:max_count] || validators[:max_count]
+      end
+
+      def max_inclusive
+        field_attributes[:max_inclusive] || validators[:max_inclusive] || field_attributes[:max_inclusive_prop]
+      end
+
+      def max_length
+        field_attributes[:max_length] || validators[:max_length]
+      end
+
+      def min_inclusive
+        field_attributes[:min_inclusive] || validators[:min_inclusive] || field_attributes[:min_inclusive_prop]
+      end
+
+      def model_attribute
+        @model_attribute ||= (model_class.try(:attribute_alias, key) || key).to_sym
+      end
+
+      def normalized_key(key)
+        return key.to_s[0...-3].to_sym if key.to_s.ends_with?('_id')
+        return key.to_s[0...-4].pluralize.to_sym if key.to_s.ends_with?('_ids')
+
+        key
+      end
+
+      def serializer_attribute
+        return serializer_attributes[key] if serializer_attributes[key]
+
+        @serializer_attribute ||= serializer_reflection
+      end
+
+      def serializer_enum
+        @serializer_enum ||= serializer_class&.enum_options(serializer_attribute.key.to_sym) if serializer_attribute
+      end
+
+      def serializer_reflection
+        k_v = serializer_reflections.find { |_k, v| (v.association || v.key) == normalized_key(key) }
+        k_v[1] if k_v
+      end
+
+      def sh_in
+        field_attributes[:sh_in] || validators[:sh_in]
+      end
+
+      def validator(klass, option_key)
+        matched_validator = validator_by_class(klass)
+
+        option_key ? matched_validator&.options.try(:[], option_key) : matched_validator.present?
+      end
+
+      def validator_by_class(klass)
+        matched_validator = attribute_validators&.detect { |v| v.is_a?(klass) }
+        return if matched_validator.blank?
+
+        matched_validator if matched_validator.options[:if].blank? && matched_validator.options[:unless].blank?
+      end
+
+      def validators
+        @validators ||= Hash[
+          VALIDATOR_SELECTORS.map do |key, klass, option_key|
+            [key, validator(klass, option_key)]
+          end
+        ]
+      end
+    end
+  end
+end

data/app/models/linked_rails/form/group.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class Form
+    class Group < LinkedRails::Resource
+      attr_accessor :fields, :collapsible, :hidden, :footer
+      attr_writer :description, :key, :label
+
+      def initialize(attrs = {})
+        super(attrs)
+        self.fields = []
+      end
+
+      def description
+        @description = @description.call if @description.respond_to?(:call)
+        @description
+      end
+
+      def label
+        @label = @label.call if @label.respond_to?(:call)
+        @label
+      end
+
+      def rdf_type
+        return Vocab.form[:CollapsibleGroup] if collapsible
+        return Vocab.form[:FooterGroup] if footer
+        return Vocab.form[:HiddenGroup] if hidden
+
+        self.class.iri
+      end
+
+      class << self
+        def iri
+          Vocab.form[:Group]
+        end
+      end
+    end
+  end
+end

data/app/models/linked_rails/form/page.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class Form
+    class Page < LinkedRails::Resource
+      attr_accessor :groups, :label, :description
+      attr_writer :key
+
+      def initialize(attrs = {})
+        super(attrs)
+        self.groups = []
+      end
+
+      def add_group(opts)
+        group = Form::Group.new(opts)
+        groups << group
+        group
+      end
+
+      def footer_group
+        @footer_group ||= add_group(collapsible: false, footer: true, key: :footer)
+      end
+
+      class << self
+        def iri
+          Vocab.form[:Page]
+        end
+      end
+    end
+  end
+end

data/app/models/linked_rails/form.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require 'pundit'
+
+module LinkedRails
+  class Form # rubocop:disable Metrics/ClassLength
+    include LinkedRails::Model
+
+    class_attribute :pages, :model_class
+
+    def root_relative_iri(_opts = {})
+      self.class.form_iri_path
+    end
+
+    class << self
+      def inherited(target)
+        target.pages = []
+      end
+
+      def form_iri
+        LinkedRails.iri(path: form_iri_path)
+      end
+
+      def form_iri_path
+        RDF::URI("/forms/#{to_s.sub(/Form$/, '').tableize}")
+      end
+
+      def form_options_iri(attr)
+        LinkedRails.iri(path: "/enums/#{model_class.to_s.tableize}/#{attr}")
+      end
+
+      def iri
+        Vocab.form[:Form]
+      end
+
+      def model_class
+        @model_class ||=
+          name.sub(/Form$/, '').safe_constantize ||
+          name.deconstantize.classify.sub(/Form$/, '').safe_constantize
+      end
+
+      def model_policy
+        @model_policy ||= Pundit::PolicyFinder.new(model_class).policy
+      end
+
+      def model_policy!
+        model_policy || raise("No policy found for #{model_class}")
+      end
+
+      def requested_single_resource(params, _user_context)
+        find_form_class(params)&.new
+      end
+
+      def serializer_attributes
+        @serializer_attributes ||= serializer_class&.attributes_to_serialize || {}
+      end
+
+      def serializer_class
+        @serializer_class ||= RDF::Serializers.serializer_for(model_class)
+      end
+
+      def serializer_reflections
+        @serializer_reflections ||= serializer_class&.relationships_to_serialize || {}
+      end
+
+      def preview_includes
+        [pages: {groups: [fields: [:fail, :pass, shape: [:property, nested_shapes: :property]]]}]
+      end
+
+      private
+
+      def current_group
+        @current_group || default_group
+      end
+
+      def current_page
+        @current_page || default_page
+      end
+
+      def default_group
+        @default_group ||= group(:default, collapsible: false)
+      end
+
+      def default_page
+        @default_page ||= page(:default)
+      end
+
+      def field(key, opts = {})
+        current_group.fields << Form::FieldFactory.new(
+          field_options: opts,
+          form: self,
+          key: key
+        ).condition_or_field
+      end
+
+      def find_form_class(params)
+        requested_class = [params[:module], "#{params[:id]&.singularize}_forms"].compact.join('/').classify
+
+        LinkedRails::Form.descendants.detect { |klass| klass.to_s == requested_class }
+      end
+
+      def footer
+        @current_group = current_page.footer_group
+
+        yield if block_given?
+
+        @current_group = nil
+        current_page.footer_group
+      end
+
+      def group(key, opts = {})
+        opts[:collapsible] = true unless opts.key?(:collapsible)
+        opts[:key] = key
+        group = current_page.add_group(opts)
+        @current_group = group
+
+        yield if block_given?
+
+        @current_group = nil
+        group
+      end
+
+      # rubocop:disable Naming/PredicateName
+      def has_many(key, opts = {})
+        opts[:input_field] = Form::Field::AssociationInput
+        opts[:max_count] = 99
+        field(key, opts)
+      end
+
+      def has_one(key, opts = {})
+        opts[:input_field] = Form::Field::AssociationInput
+        opts[:max_count] = 1
+        field(key, opts)
+      end
+      # rubocop:enable Naming/PredicateName
+
+      def hidden(&block)
+        group(:hidden, collapsible: false, hidden: true, &block)
+      end
+
+      def page(key, opts = {})
+        page = Form::Page.new(opts.merge(key: key))
+        @current_page = page
+        pages << @current_page
+        yield if block_given?
+        @current_page = nil
+        page
+      end
+
+      def resource(key, opts = {})
+        opts[:input_field] = Form::Field::ResourceField
+        field(key, opts)
+      end
+    end
+  end
+end