phlex-style_variants 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 907f0ff19a28e5800d9a1d4a0ac29697f0f8425f0c64f1547c4ce012f3a6574e
+  data.tar.gz: 1759598841f67559cde325ad73930280e05640896b9ba19db344e20cdf3b312d
+SHA512:
+  metadata.gz: dfcd75133c9301daf29326149906cbea0215fafc48fcb2136cb6baf3af0cab3179445bb0a6f70eaa05260ae1977cb93d9e3d8c4a02b65d61fe37e348a5ff82d3
+  data.tar.gz: 89e7feffcef312ed19a97af4043d5c338dc767e1ea9be457004b6b32a9cfa277a0e2ba6a107ce464c3ab43cc534ba0c3f9782f253610bce4b877997e785e22dd

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 omarluq
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,126 @@
+# phlex-style_variants
+
+[![Gem Version](https://img.shields.io/gem/v/phlex-style_variants)](https://rubygems.org/gems/phlex-style_variants)
+[![Gem Downloads](https://img.shields.io/gem/dt/phlex-style_variants)](https://www.ruby-toolbox.com/projects/phlex-style_variants)
+[![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/omarluq/phlex-style_variants/ci.yml)](https://github.com/omarluq/phlex-style_variants/actions/workflows/ci.yml)
+[![Code Climate maintainability](https://img.shields.io/codeclimate/maintainability/omarluq/phlex-style_variants)](https://codeclimate.com/github/omarluq/phlex-style_variants)
+
+Powerful Variant API for phlex component built on top of Literal
+
+> [!WARNING]
+> This gem is currently in development and is considered unstable. The API is subject to change, and you may encounter bugs or incomplete features.
+> Use it at your own risk, and contribute by reporting issues or suggesting improvements!
+
+---
+
+- [Quick start](#quick-start)
+- [Support](#support)
+- [License](#license)
+- [Code of conduct](#code-of-conduct)
+- [Contribution guide](#contribution-guide)
+
+## Features
+
+- Declarative Style Definitions: Easily define base styles and variant groups using a clean DSL.
+- Automatic Enum Generation: Automatically generates enum classes for variant groups, ensuring type safety and easy usage.
+- Inheritance Support: Create style sets that inherit from other style sets, promoting DRY (Don't Repeat Yourself) principles.
+- Variant Predicates: Built-in predicate methods to check active variants (e.g., `size.md?`).
+- Flexible Compilation: Compile styles based on active variants, allowing dynamic class generation.
+- Seamless Integration with Phlex: Designed to work effortlessly with Phlex components, enhancing their styling capabilities.
+
+## Quick start
+
+```
+gem install phlex-style_variants
+```
+
+```ruby
+require "phlex/style_variants"
+```
+
+## Usage
+
+```rb
+require "phlex/style_variants"
+
+class Button < Phlex::HTML
+  include Phlex::StyleVariants
+
+  # Define the primary style set
+  style do
+    base { 'inline-block px-4 py-2 rounded font-semibold' }
+
+    variants do
+      color do
+        primary { 'bg-blue-500 text-white' }
+        danger  { 'bg-red-500 text-white' }
+      end
+
+      size do
+        sm { 'text-sm' }
+        md { 'text-base' }
+        lg { 'text-lg' }
+      end
+    end
+  end
+
+  # Define a named style set called :wrapper with inheritance
+  style(:wrapper) do
+    base { 'p-4 bg-gray-100' }
+
+    variants do
+      border_style do
+        none   { '' }
+        dashed { 'border-2 border-dashed border-gray-400' }
+      end
+    end
+  end
+
+  prop :text, String, default: -> { 'Click Me!' }, reader: :public
+
+  def view_template
+    div(class: style(:wrapper, border_style:).compiled) do
+      button(class: style(color:, size:).compiled) do
+        text
+      end
+    end
+  end
+end
+
+# Rendering the Button component
+button = Button.new(
+  text: 'Delete',
+  color: Button::ColorEnum::Danger,
+  size: Button::SizeEnum::Lg,
+  border_style: Button::BorderStyleEnum::Dashed
+)
+button.call
+```
+
+output:
+
+```html
+<div class="p-4 bg-gray-100 border-2 border-dashed border-gray-400">
+  <button
+    class="inline-block px-4 py-2 rounded font-semibold bg-red-500 text-white text-lg"
+  >
+    Delete
+  </button>
+</div>
+```
+
+## Support
+
+If you want to report a bug, or have ideas, feedback or questions about the gem, [let me know via GitHub issues](https://github.com/omarluq/phlex-style_variants/issues/new) and I will do my best to provide a helpful answer. Happy hacking!
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](LICENSE.txt).
+
+## Code of conduct
+
+Everyone interacting in this project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](CODE_OF_CONDUCT.md).
+
+## Contribution guide
+
+Pull requests are welcome!

data/lib/phlex/style_variants/builder.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# lib/phlex/style_variants/builder.rb
+
+module Phlex
+  module StyleVariants
+    class Builder
+      def build(&)
+        @variants = {}
+        instance_eval(&) if block_given?
+        @variants
+      end
+
+      def method_missing(name, &)
+        group = VariantGroupBuilder.new(name)
+        group.instance_eval(&) if block_given?
+        @variants[name.to_sym] = group.options
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        true
+      end
+    end
+  end
+end

data/lib/phlex/style_variants/config.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# lib/phlex/style_variants/config.rb
+
+module Phlex
+  module StyleVariants
+    # Configuration class to hold multiple style sets
+    class Config < Literal::Struct
+      prop :styles, _Hash(_Symbol, Set), default: -> { {} }
+
+      # Define a new style set
+      def define(name, &)
+        styles[name.to_sym] = Set.new
+        styles[name.to_sym].instance_eval(&)
+      end
+
+      # Compile a style by name and variants
+      def compile(name, **variants)
+        style_set = styles[name.to_sym]
+        return '' unless style_set
+
+        style_set.compile(**variants)
+      end
+
+      # Create a hard copy of the config, duplicating each style set
+      def hard_copy
+        copied_styles = styles.transform_values(&:dup)
+        self.class.new(styles: copied_styles)
+      end
+    end
+  end
+end

data/lib/phlex/style_variants/set.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# lib/phlex/style_variants/set.rb
+
+module Phlex
+  module StyleVariants
+    # Represents a set of styles with base and variants
+    class Set < Literal::Struct
+      # Make 'base' _Nilable and default to nil
+      prop :__base, _Nilable(String), default: -> {}
+      prop :__variants, _Hash(_Symbol, _Hash(_Symbol, String)), default: -> { {} }
+
+      # Define base styles
+      def base(&)
+        self.__base = instance_eval(&)
+      end
+
+      # Define variants using the Builder DSL
+      def variants(&)
+        builder = Builder.new
+        self.__variants = builder.build(&)
+      end
+
+      # Compile the class string based on variants
+      def compile(**opts)
+        classes = __base ? __base.dup : ''
+
+        opts.each do |variant_group, variant_value|
+          classes += " #{variant_value.value}"
+        end
+
+        classes.strip
+      end
+    end
+  end
+end

data/lib/phlex/style_variants/style_instance.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# lib/phlex/style_variants/instance.rb
+
+module Phlex
+  module StyleVariants
+    # Represents the compiled classes and variant enums
+    class StyleInstance < Literal::Struct
+      prop :compiled, String
+      prop :variants, _Hash(_Symbol, Literal::Enum), default: -> { {} }
+
+      # Delegate variant predicate methods (e.g., size.md?) to the enums
+      def method_missing(name, *args, &block)
+        if @variants.key?(name.to_sym) && @enums.key?(name.to_sym)
+          @variants[name.to_sym].__send__("#{variants[name.to_sym]}?")
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        @variants.key?(name.to_sym) || super
+      end
+    end
+  end
+end

data/lib/phlex/style_variants/variant_group_builder.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Phlex
+  module StyleVariants
+    # Helper class to build individual variants within a group
+    class VariantGroupBuilder
+      attr_reader :options
+
+      def initialize(name)
+        @name = name
+        @options = {}
+      end
+
+      def method_missing(option_name, &)
+        @options[option_name.to_sym] = instance_eval(&)
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        true
+      end
+    end
+  end
+end

data/lib/phlex/style_variants/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Phlex
+  module StyleVariants
+    VERSION = '0.0.0'
+  end
+end

data/lib/phlex/style_variants.rb

@@ -0,0 +1,129 @@
+# lib/phlex/style_variants/style_variants.rb
+
+# frozen_string_literal: true
+
+require 'literal'
+require 'debug'
+
+module Phlex
+  module StyleVariants
+    autoload :VERSION, 'phlex/style_variants/version'
+    autoload :Builder, 'phlex/style_variants/builder'
+    autoload :VariantGroupBuilder, 'phlex/style_variants/variant_group_builder'
+    autoload :Config, 'phlex/style_variants/config'
+    autoload :Set, 'phlex/style_variants/set'
+    autoload :StyleInstance, 'phlex/style_variants/style_instance'
+
+    # Define ClassMethods for style definitions
+    module ClassMethods
+      # Define a new style set with optional inheritance
+      # Usage:
+      # style do
+      #   base { "..." }
+      #   variants do
+      #     color do
+      #       primary { "..." }
+      #       danger { "..." }
+      #     end
+      #   end
+      # end
+      #
+      # style(:wrapper, inherit: true) do
+      #   base { "..." }
+      #   variants do
+      #     border { "..." }
+      #   end
+      # end
+
+      def style_config
+        @style_config ||= if superclass.respond_to?(:style_config)
+          superclass.style_config.hard_copy
+        else
+          Config.new
+        end
+      end
+
+      def style(name = default_style_name, &)
+        style_config.define(name.to_sym, &)
+
+        # After defining the style set, define enums and props
+        style_set = style_config.styles[name.to_sym]
+        style_set.__variants.each do |variant_group, options|
+          # Define Enum Class for the Variant Group
+          enum_class = Class.new(Literal::Enum) do
+            prop :value, String
+            options.each do |option_key, option_value|
+              const_set(option_key.to_s.split('_').collect(&:capitalize).join, new(value: option_value))
+            end
+          end
+          enum_const_name = "#{variant_group.to_s.split('_').collect(&:capitalize).join}Enum".freeze
+          # Assign the Enum Class to the Component's Namespace
+          const_set(enum_const_name, enum_class)
+
+          # Define Props for the Variant Group
+          # Set the first option as the default value
+          default_variant = options.keys.first.to_s.capitalize
+          prop variant_group.to_sym, enum_class, default: enum_class.const_get(default_variant), reader: :public
+        end
+      end
+
+      # Helper method to remove module namespaces
+      def demodulize(class_name)
+        class_name.split('::').last
+      end
+
+      # Helper method to convert CamelCase to snake_case
+      def underscore(camel_cased_word)
+        word = camel_cased_word.dup
+        word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+        word.tr!('-', '_')
+        word.downcase!
+        word
+      end
+
+      # Helper method to return the string if present, else nil
+      def presence(string)
+        (string.nil? || string.strip.empty?) ? nil : string
+      end
+
+      # Determine the default style name based on the class name
+      def default_style_name
+        @default_style_name ||= begin
+          # Get the class name as a string
+          class_name = name
+
+          # Demodulize: Remove module namespaces
+          base_name = demodulize(class_name)
+
+          # Remove "Component" or "::Component" suffix
+          base_name = base_name.sub(/Component$/, '')
+
+          # Convert CamelCase to snake_case
+          style_name = underscore(base_name)
+
+          # Return the style_name if present; otherwise, default to 'component'
+          presence(style_name) || 'component'
+        end
+      end
+    end
+
+    # Define InstanceMethods for style compilation
+    module InstanceMethods
+      # Compile styles based on provided variants
+      # Usage:
+      # style(color: :primary, size: :md).size.md? # => true
+      def style(name = self.class.default_style_name, **variants)
+        compiled = self.class.style_config.compile(name.to_sym, **variants).strip
+        StyleInstance.new(compiled:, variants:)
+      end
+    end
+
+    # Hook to include ClassMethods and InstanceMethods when included
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.extend(Literal::Properties)
+      base.include(InstanceMethods)
+    end
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: phlex-style_variants
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- omarluq
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-01-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: literal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+description:
+email:
+- omar.luqman@hey.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/phlex/style_variants.rb
+- lib/phlex/style_variants/builder.rb
+- lib/phlex/style_variants/config.rb
+- lib/phlex/style_variants/set.rb
+- lib/phlex/style_variants/style_instance.rb
+- lib/phlex/style_variants/variant_group_builder.rb
+- lib/phlex/style_variants/version.rb
+homepage: https://github.com/omarluq/phlex-style_variants
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/omarluq/phlex-style_variants/issues
+  changelog_uri: https://github.com/omarluq/phlex-style_variants/releases
+  source_code_uri: https://github.com/omarluq/phlex-style_variants
+  homepage_uri: https://github.com/omarluq/phlex-style_variants
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.16
+signing_key:
+specification_version: 4
+summary: A powerful variant API for phlex components
+test_files: []