bulma_x 0.2.0

data/lib/bulma_x/columns.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module BulmaX
+  class Columns < BaseComponent
+    option :mobile, values: BOOLEAN, default: false
+    option :desktop, values: BOOLEAN, default: false
+    option :gapless, values: BOOLEAN, default: false
+    option :multiline, values: BOOLEAN, default: false
+    option :vcentered, values: BOOLEAN, default: false
+    option :centered, values: BOOLEAN, default: false
+
+    option :gap, values: (0..8).to_a.push(nil), default: nil
+    option :gap_mobile, values: (0..8).to_a.push(nil), default: nil
+    option :gap_tablet, values: (0..8).to_a.push(nil), default: nil
+    option :gap_desktop, values: (0..8).to_a.push(nil), default: nil
+    option :gap_widescreen, values: (0..8).to_a.push(nil), default: nil
+    option :gap_fullhd, values: (0..8).to_a.push(nil), default: nil
+
+    slots :column, component: 'Column'
+
+    def view_template
+      super do
+        slots(:column).each { render it }
+      end
+    end
+
+    class Column < BaseComponent
+      PROPORTIONS = %w[three-quarters two-thirds half one-third one-quarter full four-fifths three-fifths two-fifths
+                       one-fifth].freeze
+      SPANS = (1..12).to_a.freeze
+
+      option :proportion, values: PROPORTIONS, default: nil
+      option :proportion_mobile, values: PROPORTIONS, default: nil
+      option :proportion_tablet, values: PROPORTIONS, default: nil
+      option :proportion_desktop, values: PROPORTIONS, default: nil
+      option :proportion_widescreen, values: PROPORTIONS, default: nil
+      option :proportion_fullhd, values: PROPORTIONS, default: nil
+
+      option :span, values: SPANS, default: nil
+      option :offset, values: PROPORTIONS + SPANS, default: nil
+      option :narrow, values: [nil, :always, :mobile, :table, :touch, :desktop, :widescreen, :fullhd], default: nil
+
+      # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+      def root_classes
+        super +
+          [
+            'column',
+            @proportion && "is-#{@proportion}",
+            @proportion_mobile && "is-#{@proportion_mobile}-mobile",
+            @proportion_tablet && "is-#{@proportion_tablet}-tablet",
+            @proportion_desktop && "is-#{@proportion_desktop}-desktop",
+            @proportion_widescreen && "is-#{@proportion_widescreen}-widescreen",
+            @proportion_fullhd && "is-#{@proportion_fullhd}-fullhd",
+            @span && "is-#{@span}",
+            @offset && "is-offset-#{@offset}",
+            @narrow && (@narrow == :always ? 'is-narrow' : "is-narrow-#{@narrow}")
+          ]
+      end
+    end
+
+    def root_classes
+      super +
+        [
+          'columns',
+          @mobile && 'is-mobile',
+          @desktop && 'is-desktop',
+          @gapless && 'is-gapless',
+          @multiline && 'is-multiline',
+          @centered && 'is-centered',
+          @vcentered && 'is-vcentered',
+          @gap && "is-column-gap-#{@gap}",
+          @gap_mobile && "is-column-gap-#{@gap_mobile}-mobile",
+          @gap_tablet && "is-column-gap-#{@gap_tablet}-tablet",
+          @gap_desktop && "is-column-gap-#{@gap_desktop}-desktop",
+          @gap_widescreen && "is-column-gap-#{@gap_widescreen}-widescreen",
+          @gap_fullhd && "is-column-gap-#{@gap_fullhd}-fullhd"
+        ]
+    end
+    # rubocop:enable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+  end
+end

data/lib/bulma_x/component_dsl.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module BulmaX
+  module ComponentDsl
+    def self.included(base)
+      base.include(Dsl::Options)
+      base.include(Dsl::Slots)
+      base.include(Dsl::Validations)
+
+      base.instance_eval do
+        def self.inherited(subclass)
+          super
+          inherit_options(subclass)
+          inherit_validations(subclass)
+        end
+      end
+    end
+  end
+end

data/lib/bulma_x/dropdown.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module BulmaX
+  class Dropdown < BaseComponent
+    option :direction, values: %i[down up], default: 'down'
+    option :opened, values: BOOLEAN, default: false
+
+    slot :trigger, classes: ['dropdown-trigger']
+    slot :menu, classes: ['dropdown-menu'], attributes: { role: 'menu' }
+    slot :content, component: 'Content'
+    slots :item, component: 'Item'
+
+    def view_template
+      super do
+        slot(:trigger)
+        slot(:menu)
+
+        slot(:content)
+      end
+    end
+
+    def root_classes
+      super +
+        [
+          'dropdown is-hoverable',
+          @direction == :up && 'is-up',
+          @opened && 'is-active'
+        ]
+    end
+
+    class Item < BaseComponent
+      option :active, values: BOOLEAN, default: false
+      option :disabled, values: BOOLEAN, default: false
+      option :divider, values: BOOLEAN, default: false
+
+      def root_classes
+        if @divider
+          super + [
+            'dropdown-divider'
+          ]
+        else
+          super + [
+            'dropdown-item',
+            @active && 'is-active',
+            @disabled && 'is-disabled'
+          ]
+        end
+      end
+
+      def root_tag = @divider ? :hr : :a
+    end
+
+    class Content < BaseComponent
+      root_slot classes: ['dropdown-content']
+
+      slots :item, component: Item # TODO: fix reference to component
+
+      def view_template
+        super do
+          slots(:item).each { render it }
+        end
+      end
+    end
+  end
+end

data/lib/bulma_x/dsl/options.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module BulmaX
+  module Dsl
+    module Options
+      module ClassMethods
+        attr_reader :options, :default_options
+
+        def option(attribute_name, values: nil, default: nil, override: false)
+          @options ||= Hash.new { |h, k| h[k] = [] }
+          @default_options ||= {}
+
+          if @options.key?(attribute_name) && !override
+            raise ArgumentError,
+                  "Option :#{attribute_name} already defined on #{self}, use override: true to redefine it"
+          end
+
+          @options[attribute_name] = values
+          @default_options[attribute_name] = default.dup.freeze
+
+          define_prefixed_helpers(attribute_name, values)
+          define_values_helper(attribute_name, values)
+        end
+
+        def default_option(attribute_name, value)
+          @default_options ||= {}
+
+          raise ArgumentError, "Option :#{attribute_name} does not exist" unless @options.key?(attribute_name)
+
+          @default_options[attribute_name] = value.dup.freeze
+        end
+
+        def remove_option(attribute_name)
+          @options.delete(attribute_name)
+          @default_options.delete(attribute_name)
+        end
+
+        protected
+
+        def inherit_options(subclass)
+          subclass.instance_variable_set(:@options, @options.dup)
+          subclass.instance_variable_set(:@default_options, @default_options.dup)
+        end
+
+        private
+
+        def define_prefixed_helpers(attribute_name, values)
+          case values
+          in [true, false] | [false, true]
+            define_boolean_helper(attribute_name)
+          in Array
+            define_helpers(attribute_name, values)
+          in Range | nil
+          # Do nothing
+          else
+            raise ArgumentError, '#options expect an array of values'
+          end
+        end
+
+        def define_boolean_helper(attribute_name)
+          define_method(attribute_name) do
+            tap { instance_variable_set(:"@#{attribute_name}", true) }
+          end
+          define_method(:"#{attribute_name}?") do
+            instance_variable_get(:"@#{attribute_name}")
+          end
+          define_method(:"not_#{attribute_name}") do
+            tap { instance_variable_set(:"@#{attribute_name}", false) }
+          end
+        end
+
+        def define_helpers(attribute_name, values)
+          values.each do |value|
+            define_method(:"#{attribute_name}_#{value}") do
+              tap { instance_variable_set(:"@#{attribute_name}", value) }
+            end
+          end
+        end
+
+        def define_values_helper(attribute_name, values)
+          class_eval do
+            define_singleton_method(:"#{attribute_name}_values") do
+              values
+            end
+          end
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      def build_from_options(**build_options)
+        @build_options = build_options
+        return if class_options.nil?
+        return if build_options.nil?
+
+        assert_options_validity!(build_options)
+
+        class_options.each_key do |attribute|
+          value = if build_options.key?(attribute)
+                    build_options[attribute]
+                  else
+                    class_default_options[attribute].dup
+                  end
+
+          instance_variable_set(:"@#{attribute}", value)
+        end
+      end
+
+      def class_options = self.class.options
+      def class_default_options = self.class.default_options
+      def option_get(name) = instance_variable_get(:"@#{name}")
+      def option_set(name, value) = instance_variable_set(:"@#{name}", value)
+
+      def assert_options_validity!(build_options)
+        build_options.each do |key, value|
+          raise ArgumentError, "Unknown option :#{key} on #{self.class}" unless class_options.key?(key)
+
+          class_option = class_options[key]
+          next if class_option.nil? || class_option.include?(value)
+
+          raise ArgumentError,
+                "Option #{key.inspect} has invalid value #{value.inspect}, expected one of #{class_option.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/bulma_x/dsl/slots.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+module BulmaX
+  module Dsl
+    module Slots
+      module DeferredRender
+        def before_template(&)
+          @_vanishing = true
+          vanish do
+            prepare(&)
+            yield self if block_given?
+          end
+          @_vanishing = false
+          super
+        end
+
+        def prepare; end
+
+        def render(...)
+          return if @_vanishing
+
+          super
+        end
+      end
+
+      module ClassMethods
+        # slot defines a slot that will be accessible on the instance via slot
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/AbcSize
+        def slot(slot_name, tag: :div, classes: [], attributes: {}, component: Slot)
+          include DeferredRender
+
+          if component != Slot && (tag != :div || classes.any? || attributes.any?)
+            raise ArgumentError, 'When using a custom component, tag, classes and attributes are ignored'
+          end
+
+          define_tag_helper(slot_name, tag)
+          define_classes_helper(slot_name, classes)
+          define_attributes_helper(slot_name, attributes)
+
+          # TODO: Replace method usage by class variable for validation
+          # @enabled_slots ||= {}
+          # @enabled_slots[slot_name] = { collection: false, ...}
+
+          define_method(:"with_#{slot_name}") do |**options, &block|
+            @slots[slot_name] = { component:, options:, block: }
+
+            nil
+          end
+          private :"with_#{slot_name}"
+
+          define_method(:"#{slot_name}_slot_component") do
+            if component.is_a?(Class)
+              component
+            elsif component.is_a?(String)
+              if component == 'self'
+                self.class
+              else
+                self.class.const_get(component)
+              end
+            end
+          end
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/AbcSize
+
+        # slots defines a collection of slot that will be accessible on the instance via slots
+
+        # rubocop:disable Metrics
+        def slots(slot_name, tag: :div, classes: [], attributes: {}, component: Slot)
+          include DeferredRender
+
+          if component != Slot && (tag != :div || classes.any? || attributes.any?)
+            raise ArgumentError, 'When using a custom component, tag, classes and attributes are ignored'
+          end
+
+          define_tag_helper(slot_name, tag)
+          define_classes_helper(slot_name, classes)
+          define_attributes_helper(slot_name, attributes)
+
+          define_method(:"with_#{slot_name}") do |**options, &block|
+            @slots[slot_name] ||= []
+
+            @slots[slot_name] << { component:, options:, block: }
+
+            nil
+          end
+          private :"with_#{slot_name}"
+
+          define_method(:"#{slot_name}_slot_component") do
+            if component.is_a?(Class)
+              component
+            elsif component.is_a?(String)
+              if component == 'self'
+                self.class
+              else
+                self.class.const_get(component)
+              end
+            end
+          end
+        end
+        # rubocop:enable Metrics
+
+        # root_slot allows to redefine the root tag, classes and attributes in one go
+        def root_slot(**kwargs)
+          tag = kwargs[:tag] || :div
+          define_method(:root_tag) { tag }
+
+          classes = kwargs[:classes] || []
+          define_method(:root_classes) { base_classes + classes }
+
+          attributes = kwargs[:attributes] || {}
+          define_method(:root_attributes) { base_attributes.merge(attributes) }
+        end
+
+        def define_tag_helper(slot_name, tag) = define_method(:"#{slot_name}_tag") { tag }
+        def define_classes_helper(slot_name, classes) = define_method(:"#{slot_name}_classes") { classes }
+        def define_attributes_helper(slot_name, attributes) = define_method(:"#{slot_name}_attributes") { attributes }
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      def initialize(...)
+        super
+        @slots = {}
+      end
+
+      # content is used to store a slot content for later use (via slot or slots)
+      # It is meant to be used during the render context :
+      #   render Component.new { it.content(:slot_name) { 'My slot content' } }
+      def content(slot_name, **, &)
+        if respond_to?(:"with_#{slot_name}", true)
+          send(:"with_#{slot_name}", **, &)
+        else
+          raise ArgumentError,
+                "Content was called for slot `#{slot_name}`, but this slot does not exist on #{self.class}"
+        end
+      end
+
+      def slot?(slot_name, idx = 0)
+        if @slots[slot_name].is_a?(Enumerable)
+          @slots[slot_name].size > idx
+        else
+          @slots.key?(slot_name)
+        end
+      end
+      alias content? slot?
+
+      private
+
+      # slot as an instance methods displays a slot content. It has three usages:
+      # 1. In a deferred render context, it will fetch the stored slot info to render it. Note: content params have priority over view_template params
+      # 2. In a deferred render context without stored content, it uses the default rendering of the given component IF it differs from the default Slot
+      # 3. In a direct rendering context, we want to display the block content
+      # 4. In a legacy component that used to override slot method, we still support it for now
+      def slot(slot_name, **, &)
+        unless respond_to?(:"#{slot_name}_slot_component", true)
+          raise ArgumentError,
+                "Slot #{slot_name} is not defined on #{self.class}"
+        end
+
+        component = slot_name == :root ? Slot : public_send(:"#{slot_name}_slot_component")
+
+        if @slots.key?(slot_name)
+          render_content(slot_name, **, component:)
+        elsif component != Slot
+          render_custom_component(component, **, &)
+        elsif respond_to?(:"component_slot_#{slot_name}", true)
+          render_legacy_slot(slot_name, **, &)
+        else
+          render generic_slot(slot_name, **, &)
+        end
+      end
+
+      # slots as an instance method returns the list of the contents stored
+      # If no content is stored, it returns an empty array
+      # rubocop:disable Metrics/AbcSize
+      def slots(slot_name, **template_args)
+        if !@slots.key?(slot_name)
+          [] # no item given through with_<slot_name>
+        elsif !@slots[slot_name].is_a?(Enumerable)
+          raise ArgumentError, "Slot #{slot_name} is not a collection"
+        else
+          @slots[slot_name].map do |stored_slot|
+            stored_component_method_name = :"#{slot_name}_slot_component"
+
+            unless respond_to?(stored_component_method_name, true)
+              raise ArgumentError, "Slot #{slot_name} is not defined on #{self.class}"
+            end
+
+            stored_component = public_send(stored_component_method_name)
+
+            if stored_component == Slot
+              generic_slot(slot_name, **template_args, &stored_slot[:block])
+            else
+              stored_component.new(**template_args.merge(stored_slot[:options]), &stored_slot[:block])
+            end
+          end
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def render_content(slot_name, component:, **template_options)
+        slot_info = @slots[slot_name]
+        slot_options = slot_info[:options].merge(**template_options)
+
+        if component == Slot
+          render generic_slot(slot_name, **slot_options, &slot_info[:block])
+        else
+          render component.new(**slot_options, &slot_info[:block])
+        end
+      end
+
+      def render_custom_component(component, **, &)
+        render component.new(**, &)
+      end
+
+      def render_legacy_slot(slot_name, **, &)
+        # Warning.warn('using component_slot_ is deprecated and will be removed soon') # Deprecation silenced for now
+        send(:"component_slot_#{slot_name}", **, &)
+      end
+
+      def generic_slot(slot_name, **, &)
+        Slot.new(
+          tag: send(:"#{slot_name}_tag"),
+          classes: send(:"#{slot_name}_classes"),
+          attributes: send(:"#{slot_name}_attributes"),
+          **,
+                 &
+        )
+      end
+    end
+  end
+end

data/lib/bulma_x/dsl/validations.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module BulmaX
+  module Dsl
+    module Validations
+      class Error < StandardError; end
+      class InvalidValidator < StandardError; end
+
+      module ClassMethods
+        ValidatorResult = Data.define(:result, :source_location, :details, :validator)
+        Validator = Data.define(:option, :validator, :message) do
+          def valid?(component, value)
+            source_location = nil
+            result = case validator
+                     in Symbol
+                       source_location = component.method(validator).source_location
+                       component.send(validator, value)
+                     in Proc
+                       source_location = validator.source_location
+                       component.instance_exec(value, &validator)
+                     end
+
+            ValidatorResult.new(result, source_location.join(':'), message, self)
+          end
+        end
+
+        def validate(*options, validator, message: nil)
+          options.each do |option|
+            if validator.is_a?(Proc) && validator.arity != 1
+              raise InvalidValidator,
+                    'Your validator must accept exactly on argument (the option value received during initialization)'
+            end
+
+            validators << Validator.new(option, validator, message)
+          end
+        end
+
+        def remove_validations(option_name)
+          removed, @validators = validators.partition { _1.option == option_name }
+
+          removed
+        end
+
+        def validators = @validators ||= []
+
+        protected
+
+        def inherit_validations(subclass)
+          deep_dup_validators = validators.dup
+          subclass.instance_variable_set(:@validators, deep_dup_validators)
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      def validate!(**options)
+        self.class.validators.none? do |validator|
+          value = options[validator.option]
+          validation = validator.valid?(self, value)
+
+          next if validation.result
+
+          raise Error, <<~ERROR
+            Option :#{validator.option} failed validation for value #{value.inspect}.
+            #{"Details: #{validation.details}" if validation.details}
+            Validator was defined at #{validation.source_location}
+          ERROR
+        end
+      end
+    end
+  end
+end