warped 0.1.0 → 1.0.0

data/lib/warped/emails/components/layouts/main.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Warped
+  module Emails
+    module Layouts
+      class Main < Base
+        variant do
+          base do
+            [
+              "font-family: 'Open Sans', 'Roboto', 'Segoe UI', Arial, sans-serif",
+              "max-width: 600px", "margin: 20px auto 0 auto",
+              "padding: 20px 30px", "background-color: #fff",
+              "border-radius: 5px", "box-shadow: 0 0 10px rgba(0, 0, 0, 0.1)"
+            ]
+          end
+        end
+
+        slots_one :header
+        slots_one :main
+        slots_one :footer
+
+        def template(&)
+          tag.div(style:) do
+            content_tag(:div, style: "vertical-align: middle;") do
+              concat tag.header(header)
+              concat tag.main(main)
+              concat tag.footer(footer)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/warped/emails/components/link.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Warped
+  module Emails
+    class Link < Text
+      variant do
+        base { ["text-decoration: underline"] }
+      end
+
+      default_variant size: :md, color: :info, display: :inline
+
+      def initialize(text = nil, href, size: nil, color: nil, display: nil)
+        super()
+        @text = text
+        @href = href
+        @size = size
+        @color = color
+        @display = display
+      end
+
+      def text
+        content.presence || @text
+      end
+
+      def template
+        style = style(size:, color:, display:)
+
+        tag.a(text, href:, style:)
+      end
+
+      private
+
+      attr_reader :href, :size, :color, :display
+    end
+  end
+end

data/lib/warped/emails/components/spacer.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Warped
+  module Emails
+    class Spacer < Base
+      variant do
+        base { "height: 20px" }
+      end
+
+      def template(&)
+        tag.div(nil, style:)
+      end
+    end
+  end
+end

data/lib/warped/emails/components/stepper.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Warped
+  module Emails
+    class Stepper < Base
+      variant do
+        base { "padding: 20px;" }
+      end
+
+      variant :step do
+        base do
+          ["border-radius: 100%;", "width: #{width}%",
+           "max-width: #{max_width}px", "height: #{height}px",
+           "text-align: center", "line-height: #{height}px",
+           "display: inline-block", "font-size: #{height / 2}px"]
+        end
+
+        state do
+          active { ["background-color: #007bff", "color: #fff"] }
+          inactive { ["background-color: #fff", "color: #007bff"] }
+        end
+      end
+
+      variant :step_divider do
+        base do
+          ["height: 3px", "border-radius: 3px", "width: 100%"]
+        end
+
+        state do
+          active { ["background-color: #007bff;"] }
+          inactive { ["background-color: #ddd;"] }
+        end
+      end
+
+      variant :table do
+        base do
+          ["display: inline-block", "min-width: 30px", "width: #{width}%",
+           "height: #{height}px", "border-collapse: collapse", "vertical-align: middle"]
+        end
+      end
+
+      default_variant size: :md, color: :info, display: :block
+
+      def initialize(steps:, current_step: 1)
+        super()
+        @steps = steps
+        @current_step = current_step
+      end
+
+      def template
+        tag.div(style: "width: 100%") do
+          capture do
+            (1..steps).map do |step|
+              if step <= current_step
+                concat step(step, state: :active)
+              else
+                concat step(step, state: :inactive)
+              end
+
+              if step < steps
+                concat divider(state: step <= current_step ? :active : :inactive)
+              end
+            end
+          end
+        end
+      end
+
+      private
+
+      attr_reader :steps, :current_step
+
+      def step(number, state:)
+        tag.div(style: "#{style(:step, state:)}; width: #{width}%;") do
+          tag.span(number)
+        end
+      end
+
+      def divider(state:)
+        tag.table(style: style(:table)) do
+          tag.tbody(style: "width: 100%; height: 100%; display: table") do
+            tag.tr(style: "width: 100%; height: 100%") do
+              tag.td(valign: :middle,
+                     style: "vertical-align: middle; text-align: center; height: 100%; width: 100%; padding: 0 3px") do
+                tag.div(style: style(:step_divider, state:))
+              end
+            end
+          end
+        end
+      end
+
+      def width
+        (100 / (steps + (steps - 1))).round(4) - 0.8
+      end
+
+      def max_width
+        50
+      end
+
+      def height
+        50
+      end
+    end
+  end
+end

data/lib/warped/emails/components/table.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Warped
+  module Emails
+    class Table < Base
+      variant do
+        base do
+          ["border-collapse: collapse"]
+        end
+      end
+
+      variant :row do
+        base { ["border-bottom: 1px solid #f0f0f0"] }
+      end
+
+      variant :header do
+        base { ["background-color: #f9f9f9"] }
+      end
+
+      slots_one :header
+      slots_many :rows
+
+      def template
+        raise ArgumentError, "at least one row must be passed to the table" if rows.empty?
+
+        content_tag(:table, style:) do
+          concat content_tag(:thead, header, style: style(:header))
+          concat content_tag(:tbody) do
+            rows.each do |row|
+              concat content_tag(:tr, row, style: style(:row))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/warped/emails/components/text.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Warped
+  module Emails
+    class Text < Base
+      variant do
+        size do
+          xs { ["font-size: 11px", "line-height: 16px"] }
+          sm { ["font-size: 13px", "line-height: 16px"] }
+          md { ["font-size: 16px", "line-height: 24px"] }
+          lg { ["font-size: 19px", "line-height: 24px"] }
+        end
+
+        color do
+          regular     { "color: #414750" }
+          placeholder { "color: #8B939F" }
+          info        { "color: #1C51A4" }
+          success     { "color: #60830D" }
+          warning     { "color: #82620F" }
+          error       { "color: #AB2816" }
+        end
+
+        align do
+          left   { "text-align: left" }
+          right  { "text-align: right" }
+          center { "text-align: center" }
+        end
+
+        weight do
+          regular  { "font-weight: 400" }
+          bold     { "font-weight: 700" }
+        end
+
+        display do
+          block  { "display: block" }
+          inline { "display: inline" }
+        end
+      end
+
+      default_variant size: :md, color: :regular, weight: :regular, display: :block
+
+      def initialize(text = nil, size: nil, color: nil, weight: nil, align: nil, display: nil)
+        super()
+        @text = text
+        @size = size
+        @color = color
+        @weight = weight
+        @align = align
+        @display = display
+      end
+
+      def text
+        content.presence || @text
+      end
+
+      def template(&)
+        style = style(size:, color:, weight:, align:, display:)
+
+        tag.p(text, style:)
+      end
+
+      private
+
+      attr_reader :size, :color, :weight, :align, :display
+    end
+  end
+end

data/lib/warped/emails/helpers.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Warped
+  module Emails
+    module Helpers
+      extend ActiveSupport::Concern
+
+      included do
+        helper_method :frontend_url
+      end
+
+      def frontend_url(path = [])
+        frontend_path = Array(path)
+
+        url = base_url
+        path ? [url, *frontend_path].join("/").gsub(%r{(?<!:)//}, "/") : url
+      end
+
+      def base_url
+        ENV["FRONTEND_URL"].presence || ENV["SERVER_HOST"].presence || "http://localhost:3000"
+      end
+    end
+  end
+end

data/lib/warped/emails/slottable.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Warped
+  module Emails
+    module Slottable
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def slots_one(name)
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            # def with_header(&block)
+            #   slots[:one][:header] = block
+            # end
+            #
+            # def header
+            #   capture(&slots[:one][:header]) if slots[:one][:header]
+            # end
+            def with_#{name}(&block)
+              slots[:one][:#{name}] = block
+            end
+
+            def #{name}
+              capture(&slots[:one][:#{name}]) if slots[:one][:#{name}]
+            end
+          RUBY
+        end
+
+        def slots_many(name)
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            # def with_column(&block)
+            #   slots[:many][:columns] ||= []
+            #   slots[:many][:columns] << block
+            # end
+            #
+            # def columns
+            #   return [] if slots[:many][:columns].empty?
+            #
+            #   slots[:many][:columns].map { |block| capture(&block) }
+            # end
+            def with_#{name.to_s.singularize}(&block)
+              slots[:many][:#{name}] ||= []
+              slots[:many][:#{name}] << block
+            end
+
+            def #{name}
+              return [] if slots[:many][:#{name}].empty?
+
+              slots[:many][:#{name}].map { |block| capture(&block) }
+            end
+          RUBY
+        end
+      end
+
+      def slots
+        @slots ||= { one: {}, many: {} }
+      end
+    end
+  end
+end

data/lib/warped/emails/styleable.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/enumerable"
+require "active_support/core_ext/hash/deep_merge"
+require "active_support/core_ext/module/delegation"
+require "active_support/core_ext/object/deep_dup"
+
+module Warped
+  module Emails
+    module Styleable
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        attr_writer :default_variants, :base_styles, :variants
+
+        def inherited(subclass)
+          super
+
+          subclass.default_variants = default_variants.deep_dup.deep_merge!(subclass.default_variants)
+          subclass.base_styles = base_styles.deep_dup.deep_merge!(subclass.base_styles)
+          subclass.variants = variants.deep_dup.deep_merge!(subclass.variants)
+        end
+
+        def default_variants
+          @default_variants ||= {}
+        end
+
+        def base_styles
+          @base_styles ||= {}
+        end
+
+        def variants
+          @variants ||= {}
+        end
+
+        def variant(name = :_base_variant, &)
+          raise ArgumentError, "You must provide a block" unless block_given?
+
+          variant_builder = VariantBuilder.new(self, variant_name: name)
+          variant_builder.compile_variants(&)
+        end
+
+        def default_variant(variant_name = :_base_variant, **kwargs)
+          raise ArgumentError, "You must provide a hash" unless kwargs.is_a?(Hash)
+
+          self.default_variants ||= {}
+          self.default_variants[variant_name] ||= {}
+          self.default_variants[variant_name].merge!(kwargs)
+        end
+      end
+
+      def default_variants
+        self.class.default_variants
+      end
+
+      def base_styles
+        self.class.base_styles
+      end
+
+      def variants
+        self.class.variants
+      end
+
+      def style(variant_name = :_base_variant, **kwargs)
+        base_style_arr = base_block_value(variant_name)
+
+        validate_variants!(variant_name, **kwargs)
+
+        default_variants[variant_name] ||= {}
+        default_variants[variant_name].merge(kwargs.compact_blank).each do |group_name, subvariant_name|
+          subvariant_arr = variant_block_value(variant_name, group_name, subvariant_name)
+          base_style_arr.concat(subvariant_arr)
+        end
+
+        base_style_arr.join("; ")
+      end
+
+      # @!visibility private
+      class VariantBuilder < BasicObject
+        delegate :variants, to: :@component
+
+        def initialize(component, variant_name: :_base_variant, group_name: nil)
+          @component = component
+          @group_name = group_name
+          @variant_name = variant_name
+        end
+
+        def compile_variants(&)
+          instance_eval(&)
+        end
+
+        def method_missing(name, &)
+          return super unless ::Kernel.block_given?
+
+          if !@group_name && name == :base
+            _define_base_style(&)
+          elsif !@group_name
+            _define_variant_group(name, &)
+          else
+            _define_subvariant(name, &)
+          end
+        end
+
+        def respond_to_missing?(...) = true
+
+        private
+
+        def _define_variant_group(name, &)
+          VariantBuilder.new(@component, variant_name: @variant_name, group_name: name).compile_variants(&)
+        end
+
+        def _define_subvariant(name, &block)
+          variants[@variant_name] ||= {}
+          variants[@variant_name][@group_name] ||= {}
+          variants[@variant_name][@group_name][name] = block
+        end
+
+        def _define_base_style(&block)
+          @component.base_styles[@variant_name] = block
+        end
+      end
+
+      private_constant :VariantBuilder
+
+      private
+
+      def base_block_value(variant_name)
+        return [] unless base_styles.key?(variant_name.to_sym)
+
+        base_block = base_styles[variant_name.to_sym]
+        Array.wrap(instance_eval(&base_block))
+      end
+
+      def variant_block_value(variant_name, group_name, subvariant_name)
+        return [] if subvariant_name.nil?
+
+        variant_block = self.class.variants[variant_name][group_name.to_sym][subvariant_name.to_sym]
+        Array.wrap(instance_eval(&variant_block))
+      end
+
+      def validate_variants!(name, **kwargs)
+        kwargs.each do |group_name, variant_name|
+          next if variant_name.nil?
+
+          unless variants[name].key?(group_name.to_sym)
+            raise ArgumentError,
+                  "Invalid variant group: #{group_name}"
+          end
+
+          unless variants[name][group_name.to_sym].key?(variant_name.to_sym)
+            raise ArgumentError,
+                  "Invalid variant name: #{variant_name}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/warped/engine.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "rails"
+
+module Warped
+  class Engine < ::Rails::Engine
+    isolate_namespace Warped
+
+    initializer "warped.assets" do
+      if Rails.application.config.respond_to?(:assets)
+        Rails.application.config.assets.precompile += %w[warped_manifest.js]
+      end
+    end
+
+    initializer "warped.importmap", before: "importmap" do |app|
+      app.config.importmap.paths << Engine.root.join("config/importmap.rb") if Rails.application.respond_to?(:importmap)
+    end
+  end
+end

data/lib/warped/queries/filter.rb

@@ -10,22 +10,22 @@ module Warped
     # This class provides a simple interface for filtering a scope by a set of conditions.
     # The conditions are passed as an array of hashes, where each hash contains the following
     # keys:
-    # - +relation+: the relation to use for the filter (e.g. "=", ">", "in", etc.)
+    # - +relation+: the relation to use for the filter (e.g. "eq", "gt", "in", etc.)
     # - +field+: the field to filter by
     # - +value+: the value to filter by
     #
     #
     # @example Filter a scope by a set of conditions
     #   Warped::Queries::Filter.call(User.all, filter_conditions: [
-    #     { relation: "=", field: :first_name, value: "John" },
-    #     { relation: ">", field: :age, value: 18 }
+    #     { relation: "eq", field: :first_name, value: "John" },
+    #     { relation: "gt", field: :age, value: 18 }
     #   ])
     #   # => #<ActiveRecord::Relation [...]>
     #
     # @see RELATIONS
     # To see the list of available relations, check the +RELATIONS+ constant.
     class Filter
-      RELATIONS = %w[= != > >= < <= between in not_in starts_with ends_with contains is_null is_not_null].freeze
+      RELATIONS = ::Warped::Filter::Base::RELATIONS.freeze
 
       # @param scope [ActiveRecord::Relation] the scope to filter
       # @param filter_conditions [Array<Hash>] the conditions to filter by
@@ -66,26 +66,46 @@ module Warped
 
       def filtered_scope(scope, relation, field, value)
         case relation
-        when "=", "in"
+        when "eq"
           scope.where(field => value)
-        when "!=", "not_in"
+        when "in"
+          scope.where(field => Array.wrap(value))
+        when "neq", "not_in"
           scope.where.not(field => value)
         when "between"
-          scope.where("#{field} BETWEEN ? AND ?", value.first, value.last)
+          scope.where(field => value.first..value.last)
         when "starts_with"
-          scope.where("#{field} LIKE ?", "#{value}%")
+          scope.where(arel_table_for(scope, field).matches("#{value}%"))
         when "ends_with"
-          scope.where("#{field} LIKE ?", "%#{value}")
+          scope.where(arel_table_for(scope, field).matches("%#{value}"))
         when "contains"
-          scope.where("#{field} LIKE ?", "%#{value}%")
+          scope.where(arel_table_for(scope, field).matches("%#{value}%"))
         when "is_null"
           scope.where(field => nil)
         when "is_not_null"
           scope.where.not(field => nil)
-        else # '>', '>=', '<', '<='
-          scope.where("#{field} #{relation} ?", value)
+        when "gt"
+          scope.where.not(field => ..value)
+        when "gte"
+          scope.where(field => value..)
+        when "lt"
+          scope.where.not(field => value..)
+        when "lte"
+          scope.where(field => ..value)
         end
       end
+
+      # @param scope [ActiveRecord::Relation]
+      # @param field [String|Symbol]
+      # @return [Arel::Table]
+      #  The arel table for the given field. If the field has the format "table.column",
+      #  the method will return the table for the field's table and column.
+      def arel_table_for(scope, field)
+        column, relation = field.to_s.split(".").reverse
+        return scope.arel_table[column.to_sym] unless relation
+
+        scope.arel_table.alias(relation.to_sym)[column.to_sym]
+      end
     end
   end
 end

data/lib/warped/table/action.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/delegation"
+
+module Warped
+  module Table
+    class Action
+      attr_reader :options
+
+      delegate :[], to: :options
+
+      # @param name [String | Symbol | Proc] The name of the action
+      # @param path [String | Symbol | Proc] The path of the action
+      def initialize(name, path, **options)
+        @name = name
+        @path = path
+        @options = options
+      end
+
+      def path(...)
+        return @path.call(...) if @path.is_a?(Proc)
+
+        @path
+      end
+
+      def name(...)
+        return @name.call(...) if @name.is_a?(Proc)
+
+        @name
+      end
+    end
+  end
+end