frontyard 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 960f8a9f31969989aba04d9cd0fddff4153b60df76259be27e198324eb458e98
+  data.tar.gz: 6b5e2e66c25ac43087e9236c0631321b308fb23f48c740c82fce9395bc76d39a
+SHA512:
+  metadata.gz: 8911bfaa2be547720a2a1567b4018e6e3d21b0dd8fc6100543e4672cf702f3e772aef2e1916c1044050c1106cd0ed00d111a5f247d2ad34d234f28315b2d5fb4
+  data.tar.gz: 90f8f27eaae7a36bfa4eb1f8a8a7c5311393dc756de4415bfaca993875939047121f95c219254eb6a4fa025dadd2ac410d50263c02ba8ca1ce73b9098b3777ac

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright Jim Gay
+
+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,34 @@
+# Frontyard
+Make it easier to use Phlex views, forms, and components.
+
+Very much work in progress to find some common patterns.
+
+## Usage
+
+TODO…
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem "frontyard"
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install frontyard
+```
+
+## Contributing
+
+## Releasing
+
+This gem uses [Reissue](https://github.com/SOFware/reissue) for versioning and changelog management.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,25 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"
+
+require "reissue/gem"
+
+require "rake/testtask"
+
+Reissue::Task.create do |t|
+  t.version_file = "frontyard/version.rb"
+end
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.warning = false
+end
+
+task default: :test

data/app/components/frontyard/actions.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Frontyard
+  class Actions < Frontyard::ApplicationComponent
+    ButtonConfig = Config.init(
+      buttons: {
+        submit: {
+          type: "submit",
+          text: "Submit"
+        },
+        cancel: {
+          type: "cancel",
+          text: "Cancel"
+        }
+      }
+    )
+
+    def initialize(**kwargs, &block)
+      filtered_kwargs = filter_kwargs_for(self.class.superclass, kwargs)
+      super(&block)
+      @button_config = ButtonConfig.merge(kwargs.except(*filtered_kwargs.keys))
+    end
+
+    def view_template(&block)
+      div(**self.class.config) do
+        if block_given?
+          yield
+        else
+          @button_config[:buttons].each do |_key, data|
+            button(type: data[:type]) { data[:text] }
+          end
+        end
+      end
+    end
+  end
+end

data/app/components/frontyard/application_component.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module Frontyard
+  class ApplicationComponent < Phlex::HTML
+    include Phlex::Rails::Helpers::Routes
+    include Phlex::Rails::Helpers::DOMID
+    include Phlex::Rails::Helpers::LinkTo
+    include Phlex::Rails::Helpers::ButtonTo
+
+    class << self
+      def default_config
+        @default_config ||= Config.init(
+          class: generate_css_class
+        )
+      end
+
+      def generate_css_class
+        return "" if name == "Frontyard::ApplicationComponent"
+        class_name = name
+        if class_name.to_s.start_with?("Frontyard::") && class_name.to_s != "Frontyard::ApplicationComponent"
+          return class_name.split("::").map { |part| part.gsub(/([A-Z])/, '-\1').downcase.sub(/^-/, "") }.join("-")
+        end
+        return "frontyard-component" if class_name.nil? || class_name.start_with?("#<")
+        this_css_class = class_name.split("::").last.gsub(/([A-Z])/, '-\1').downcase.sub(/^-/, "")
+        if superclass.respond_to?(:generate_css_class)
+          css_class = Contours::StructuredString.new(superclass.generate_css_class)
+          css_class << this_css_class
+        else
+          this_css_class
+        end.to_s
+      end
+
+      def config
+        @config ||= default_config
+      end
+
+      private
+
+      def configure(**kwargs)
+        @config = Config.init(kwargs)
+      end
+    end
+
+    def before_template
+      if Rails.env.development?
+        comment { "Before #{self.class.name}" }
+      end
+      super
+    end
+
+    def html_options
+      @html_options || self.class.config
+    end
+
+    def namespace = @namespace ||= begin
+      ns = self.class.name.deconstantize
+      ns.empty? ? Object : Object.const_get(ns)
+    end
+
+    # Define an initialize method along with attr_accessors
+    #
+    # Example:
+    #   initialize_with :some, :keyword, optional: nil
+    #   initialize_with :some, :keyword, optional: nil do
+    #     @processed_data = some.upcase
+    #   end
+    def self.initialize_with(*keys, **kwargs, &block)
+      mod = Module.new
+      tokens = keys.map do |key|
+        [
+          "#{key}:",
+          "@#{key} = #{key}"
+        ]
+      end.to_h
+      kwargs.each do |key, value|
+        value ||= "nil"
+        tokens["#{key}: #{value}"] = "@#{key} = #{key}"
+      end
+      accessors = keys + kwargs.keys
+      keyword_args = tokens.keys
+      ivars = tokens.values
+
+      # Include the block code in the initialize method if provided
+      block_code = if block_given?
+        # Convert the block to a string representation that can be executed
+        # This is a simplified approach - in practice you might want to use a more robust method
+        "instance_eval(&self.class.instance_variable_get(:@initialize_block))"
+      else
+        ""
+      end
+
+      mod.class_eval <<~RUBY, __FILE__, __LINE__ + 1
+        def initialize(#{keyword_args.join(", ")}, **options)
+          #{ivars.join("\n")}
+          @flash = options.delete(:flash) || {}
+          if options.key?(:html_options)
+            @html_options = options.delete(:html_options)
+          end
+          @options = options
+          yield self if block_given?
+          #{block_code}
+        end
+      RUBY
+      accessors += [:flash, :options, :html_options]
+      attr_accessor(*accessors)
+      const_set(:Initializer, mod)
+      include mod
+
+      # Store the block for execution on instances
+      @initialize_block = block if block_given?
+    end
+
+    # Helper to filter kwargs for a class's initialize method
+    private def filter_kwargs_for(klass, kwargs)
+      accepted = klass.instance_method(:initialize).parameters
+        .select { |type, _| type == :key || type == :keyreq }
+        .map(&:last)
+      kwargs.slice(*accepted)
+    end
+
+    # Helper to safely try multiple constant names
+    private def safe_const_get(*names)
+      names.each do |name|
+        return Object.const_get(name)
+      rescue NameError
+        next
+      end
+      raise NameError, "None of the constants found: #{names.join(", ")}"
+    end
+
+    # Rendere the partials that represent a model
+    #
+    # Example:
+    #   render_model something: value
+    #   render_model something: value, from: "widgets/widget"
+    def render_model(from: nil, **kwargs)
+      const_names = if from
+        base = from.classify
+        [base, "#{base}Component"]
+      else
+        namespace = self.class.name.deconstantize
+        model_name = namespace.demodulize.singularize
+        [
+          "#{namespace}::#{model_name}",
+          "#{namespace}::#{model_name}Component"
+        ]
+      end
+      klass = safe_const_get(*const_names)
+      filtered_kwargs = filter_kwargs_for(klass, kwargs)
+      render klass.new(**filtered_kwargs)
+    end
+
+    # Render a table component
+    #
+    # Example:
+    #   render_table from: "widgets/widget"
+    #   render_table from: "widgets/widget", columns: [:name, :description]
+    def render_table(from: nil, **kwargs, &block)
+      const_names = if from
+        base = from.classify
+        [base, "#{base}Table"]
+      elsif self.class.name.include?("::")
+        # For top-level classes (no namespace), try Frontyard namespace first
+        namespace = self.class.name.deconstantize
+        [
+          "#{namespace}::Table",
+          "#{namespace}::#{self.class.name.demodulize}Table",
+          "#{self.class.name}Table"
+        ]
+      else
+        # Top-level class, try Frontyard namespace with common table names
+        [
+          "Frontyard::TestTable",
+          "Frontyard::Table",
+          "Frontyard::#{self.class.name}Table",
+          "#{self.class.name}Table"
+        ]
+      end
+      klass = safe_const_get(*const_names)
+      filtered_kwargs = filter_kwargs_for(klass, kwargs)
+      render klass.new(**filtered_kwargs, &block)
+    end
+
+    def params = helpers.params
+
+    def view_template(&) = div(**html_options, &)
+  end
+end

data/app/components/frontyard/application_form.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Frontyard
+  class ApplicationForm < Frontyard::ApplicationComponent
+    include Phlex::Rails::Helpers::DatetimeField
+    include Phlex::Rails::Helpers::FormWith
+    include Phlex::Rails::Helpers::Label
+    include Phlex::Rails::Helpers::Pluralize
+    include Phlex::Rails::Helpers::TextField
+
+    def form_actions(**kwargs, &block)
+      render Frontyard::Actions.new(**kwargs, &block)
+    end
+
+    def field(attribute, **kwargs, &block)
+      # Use the form object if available, otherwise use a default object
+      form_object = respond_to?(:object) ? object : self
+      render Frontyard::Field.new(object: form_object, attribute: attribute, **kwargs, &block)
+    end
+
+    # Default object method - subclasses can override this
+    def object
+      nil
+    end
+
+    DateTimeParamTransformer = Data.define(:keys, :hash) do
+      def call(time_converter: Time.zone.method(:local))
+        leaf = keys.pop
+        data = keys.reduce(hash) do |memo, key|
+          memo[key] ||= {}
+        end
+
+        values = []
+        # Check for both string and symbol keys
+        datetime_keys = [
+          "#{leaf}(1i)", :"#{leaf}(1i)",
+          "#{leaf}(2i)", :"#{leaf}(2i)",
+          "#{leaf}(3i)", :"#{leaf}(3i)",
+          "#{leaf}(4i)", :"#{leaf}(4i)",
+          "#{leaf}(5i)", :"#{leaf}(5i)"
+        ]
+
+        datetime_keys.each_slice(2) do |string_key, symbol_key|
+          value = data.delete(string_key) || data.delete(symbol_key)
+          values << value if value
+        end
+
+        # Filter out nil values and provide defaults
+        filtered_values = values.compact
+        if filtered_values.empty?
+          # If no values provided, use current time
+          Time.current
+        else
+          # Pad with defaults for missing parts
+          year = filtered_values[0] || Time.current.year
+          month = filtered_values[1] || 1
+          day = filtered_values[2] || 1
+          hour = filtered_values[3] || 0
+          minute = filtered_values[4] || 0
+
+          time_converter.call(year, month, day, hour, minute)
+        end
+      end
+    end
+
+    class << self
+      def process_params(params)
+        params
+      end
+
+      private
+
+      def format_date_parts(*keys, params:)
+        DateTimeParamTransformer.new(keys: keys, hash: params).call
+      end
+    end
+  end
+end

data/app/components/frontyard/application_table.rb

@@ -0,0 +1,11 @@
+module Frontyard
+  class ApplicationTable < ApplicationComponent
+    def render_row(**kwargs, &block)
+      if self.class.const_defined?(:Row)
+        render self.class::Row.new(**kwargs, &block)
+      else
+        tr(**kwargs, &block)
+      end
+    end
+  end
+end

data/app/components/frontyard/application_view.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Frontyard
+  class ApplicationView < ::Frontyard::ApplicationComponent
+    include Phlex::Rails::Helpers::ContentFor
+
+    def page_links(&)
+      render PageLinks.new(&)
+    end
+
+    def render_form(**)
+      render namespace::Form.new(**)
+    end
+
+    def render_fragment(namespace: nil, **)
+      namespace ||= self.namespace
+      render "#{namespace}::Fragment".constantize.new(**)
+    end
+
+    def notice = flash[:notice]
+
+    def alert = flash[:alert]
+
+    def error = flash[:error]
+  end
+end

data/app/components/frontyard/components.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Frontyard
+  module Components
+    extend Phlex::Kit
+  end
+end

data/app/components/frontyard/field.rb

@@ -0,0 +1,66 @@
+module Frontyard
+  class Field < Frontyard::ApplicationComponent
+    include Phlex::Rails::Helpers::FormWith
+    include Phlex::Rails::Helpers::Label
+    include Phlex::Rails::Helpers::Pluralize
+    include Phlex::Rails::Helpers::TextField
+    include Phlex::Rails::Helpers::NumberField
+    include Phlex::Rails::Helpers::CheckBox
+    include Phlex::Rails::Helpers::DateSelect
+    include Phlex::Rails::Helpers::OptionsForSelect
+    include Phlex::Rails::Helpers::Select
+
+    initialize_with :object, :attribute
+
+    def view_template(&block)
+      div(**self.class.config) do
+        # Use basic HTML label to avoid Rails helper conflicts
+        tag(:label) { attribute.to_s.humanize }
+
+        case field_type
+        when :text
+          input(type: "text", name: object_attribute, **field_options)
+        when :number
+          input(type: "number", name: object_attribute, **field_options)
+        when :date
+          input(type: "date", name: object_attribute, **field_options)
+        when :checkbox
+          input(type: "checkbox", name: object_attribute, **field_options)
+        else
+          input(type: "text", name: object_attribute, **field_options)
+        end
+        yield if block_given?
+      end
+    end
+
+    private
+
+    def object_attribute
+      if object&.class&.respond_to?(:name)
+        "#{object.class.name.underscore}[#{attribute}]"
+      else
+        # Fallback for when object is nil or doesn't have a class name
+        attribute.to_s
+      end
+    end
+
+    def field_type
+      # Determine field type based on attribute or object type
+      case attribute.to_s
+      when /_at$/, /_on$/
+        :date
+      when /_count$/, /_id$/
+        :number
+      when /_enabled$/, /_active$/
+        :checkbox
+      else
+        :text
+      end
+    end
+
+    def field_options
+      # Return any additional options for the field
+      {}
+    end
+  end
+end

data/app/components/frontyard/fields.rb

@@ -0,0 +1,35 @@
+module Frontyard
+  class Fields < Frontyard::ApplicationComponent
+    DefaultConfig = Config.init(
+      class: "frontyard-fields"
+    )
+
+    def field(*args, **kwargs, &block)
+      name = args.first
+      options = kwargs
+      div(class: "frontyard-field") do
+        label do
+          plain(name.to_s.humanize)
+          input(type: options[:type] || "text", name: name, **render_attributes(options))
+        end
+      end
+    end
+
+    private
+
+    def render_attributes(options)
+      attrs = options.except(:type)
+      # Handle boolean attributes
+      attrs.transform_values! do |value|
+        if value.is_a?(TrueClass)
+          value.to_s
+        elsif value.is_a?(FalseClass)
+          nil
+        else
+          value
+        end
+      end
+      attrs.compact
+    end
+  end
+end

data/app/components/frontyard/page_links.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Frontyard
+  class PageLinks < Frontyard::ApplicationComponent
+    def page_link(text, url, **options)
+      options = {
+        class: "page-link"
+      }.merge(options)
+      link_to text, url, **options
+    end
+
+    def button(text, object, **options)
+      options = {
+        class: "page-button",
+        form: {class: "inline-button-form"}
+      }.merge(options)
+      button_to text, object, **options
+    end
+
+    def dangerous_button(text, object, options)
+      options = {
+        class: "page-button dangerous"
+      }.merge(options)
+      button(text, object, **options)
+    end
+  end
+end

data/app/controllers/frontyard/controller.rb

@@ -0,0 +1,39 @@
+module Frontyard
+  module Controller
+    # Get the form class for the current controller
+    def form
+      namespace = controller_name.camelize
+      ::Views.const_get("#{namespace}::Form")
+    end
+
+    def form_params
+      form.process_params(params)
+    end
+
+    def render_view(action_name: self.action_name, **kwargs)
+      klass = "views/#{controller_name}/#{action_name}".classify.constantize
+      # Get the initialize parameters from the view class
+      init_params = klass.instance_method(:initialize).parameters
+      # Symbolize all keys in kwargs
+      symbolized_kwargs = kwargs.transform_keys(&:to_sym)
+      # Start with kwargs, but fill in required params from controller if missing
+      view_data = {}
+      init_params.each do |type, name|
+        sym_name = name.to_sym
+        if symbolized_kwargs.key?(sym_name)
+          # Parameter was provided in kwargs
+          view_data[sym_name] = symbolized_kwargs[sym_name]
+        elsif type == :keyreq && respond_to?(name, true)
+          # Required parameter not provided, call controller method
+          view_data[sym_name] = send(name)
+        elsif type == :key && respond_to?(name, true)
+          # Optional parameter not provided, call controller method
+          view_data[sym_name] = send(name)
+        end
+      end
+      view_data[:flash] = flash
+      render_data = symbolized_kwargs.except(*view_data.keys)
+      render klass.new(**view_data), **render_data
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,2 @@
+Rails.application.routes.draw do
+end

data/lib/frontyard/engine.rb

@@ -0,0 +1,19 @@
+require "phlex-rails"
+
+module Frontyard
+  class Engine < ::Rails::Engine
+    isolate_namespace Frontyard
+
+    initializer "frontyard.controller" do
+      ActiveSupport.on_load(:action_controller) do
+        include Frontyard::Controller
+      end
+    end
+
+    initializer "frontyard.view" do
+      ActiveSupport.on_load(:action_view) do
+        Dir[Frontyard::Engine.root.join("app/views/frontyard/**/*.rb")].each { |file| require file }
+      end
+    end
+  end
+end

data/lib/frontyard/version.rb

@@ -0,0 +1,3 @@
+module Frontyard
+  VERSION = "0.1.0"
+end

data/lib/frontyard.rb

@@ -0,0 +1,12 @@
+require_relative "frontyard/version"
+require_relative "frontyard/engine"
+require "contours"
+
+module Frontyard
+  extend Phlex::Kit
+
+  class Config < Contours::BlendedHash
+    @blended_keys = [:class]
+    blend :class, with: Contours::StructuredString
+  end
+end

data/lib/tasks/frontyard_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :frontyard do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: frontyard
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jim Gay
+bindir: bin
+cert_chain: []
+date: 2025-07-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.0.0
+- !ruby/object:Gem::Dependency
+  name: phlex-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+- !ruby/object:Gem::Dependency
+  name: contours
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+description: Use Frontyard in your rails app to simplify the use of Phlex views.
+email:
+- jim@saturnflyer.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/components/frontyard/actions.rb
+- app/components/frontyard/application_component.rb
+- app/components/frontyard/application_form.rb
+- app/components/frontyard/application_table.rb
+- app/components/frontyard/application_view.rb
+- app/components/frontyard/components.rb
+- app/components/frontyard/field.rb
+- app/components/frontyard/fields.rb
+- app/components/frontyard/page_links.rb
+- app/controllers/frontyard/controller.rb
+- config/routes.rb
+- lib/frontyard.rb
+- lib/frontyard/engine.rb
+- lib/frontyard/version.rb
+- lib/tasks/frontyard_tasks.rake
+homepage: https://github.com/saturnflyer/frontyard
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/saturnflyer/frontyard
+  source_code_uri: https://github.com/saturnflyer/frontyard
+  changelog_uri: https://github.com/saturnflyer/frontyard/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.5
+specification_version: 4
+summary: Frontyard is a Rails engine for creating and managing views with Phlex.
+test_files: []