nitro_rails 0.1.0 → 0.1.1

data/app/helpers/nitro_rails/nitro_form_helper.rb

@@ -0,0 +1,104 @@
+module NitroRails
+  module NitroFormHelper 
+    def nitro_form(**options, &block)
+      nitro_options(options) do |options|
+        options.default(:builder, NitroFormBuilder)
+        options.default(:data, :turbo, true)
+        options.concat(:data, :controller, "nitro-form")
+        options.concat(:data, :nitro_form_target, "form")
+        options.concat(:data, :nitro_form_resource_target_value, options[:model].nitro_id) if options[:model] && options[:model].persisted?
+        options.concat(:data, :nitro_effects, effects_for(options[:method]))
+      end
+
+      form_with(**options, &block)
+    end
+
+    def effects_for(method)
+      case method
+      when :post
+        "insertItemAndFocus attributeEffects"
+      when :patch, :put
+        "attributeEffects"
+      when :delete
+        "removeItem"
+      else
+        nil
+      end
+    end
+
+    class NitroFormBuilder < ActionView::Helpers::FormBuilder
+      include NitroRails::NitroOptionsHelper
+
+      ############
+      ## SUBMIT ##
+      ############
+
+      def submit_div(**options, &block)
+        nitro_options(options) do |options|
+          options.default(:class, "nitro-form-submit")
+          options.concat(:data, :action, "click->nitro-form#submit")
+        end
+
+        @template.content_tag(:div, **options, &block)
+      end
+
+      # Don't know if this works.
+      def submit(text = nil, **options, &block)
+        nitro_options(options) do |options|
+          options.default(:class, "btn button_to")
+          options.concat(:data, :action, "click->nitro-form#submit")
+        end
+
+        super(text, **options, &block)
+      end
+
+      ###################
+      ## HIDDEN FIELDS ##
+      ###################
+
+      def generate_hidden_attribute_fields()
+        object_key = @object.class.name.underscore.to_sym
+        attributes = {}
+
+        if @object 
+          @object.changes.each do |attribute, (old_value, new_value)|
+            attributes[attribute] = new_value
+          end
+        end
+
+        if @options[:params] && @options[:params][object_key]
+          attributes.merge!(@options[:params][object_key])
+        end
+
+        attributes.map do |attribute, value|
+          hidden_attribute_field(attribute, value)
+        end.join.html_safe + 
+        if @options[:belongs_to]
+          hidden_affiliation_field(@options[:belongs_to])
+        end
+      end
+
+      def hidden_affiliation_field(affiliation, **options)
+        nitro_options(options) do |options|
+          options.override(:value, affiliation.id)
+          options.default(:data, :nitro_form_target, "field")
+          options.concat(:data, :nitro_effects, "addToAffiliatedLists")
+          options.override(:data, :nitro_attribute, affiliation.nitro_id(@object.type.pluralize))
+        end
+
+        hidden_field("#{affiliation.class.name.underscore}_id", **options)
+      end
+
+      def hidden_attribute_field(attribute, value, **options)
+        nitro_options(options) do |options|
+          options.override(:value, value)
+          options.default(:data, :nitro_form_target, "field")
+          options.concat(:data, :nitro_effects, @object.attribute_effects(attribute).join(" ").camelize(:lower))
+          options.override(:data, :nitro_attribute, attribute.to_s)
+        end
+        
+        hidden_field(attribute, **options)
+      end
+    end
+  end 
+end

data/app/helpers/nitro_rails/nitro_options_helper.rb

@@ -0,0 +1,78 @@
+# Maybe could move to lib folder
+module NitroRails 
+  module NitroOptionsHelper
+    def nitro_options(*options, &block)
+      nitro_options = NitroOptions.new(*options)
+      nitro_defaults(nitro_options)
+      # app_defaults(nitro_options)
+      yield nitro_options
+      return nitro_options.options
+    end
+
+    # This shouldn't need to be run every time nitro_options is called
+    def nitro_defaults(nitro_options)
+      nitro_options.translate(:audio) do |value|
+        nitro_options.concat(:data, :controller, "audio")
+        nitro_options.concat(:data, :action, "audio#play")
+        nitro_options.concat(:data, :audio, value)
+      end
+
+      # Need to deal with adding styles when style key already exists
+      if(nitro_options.options[:style].class == Hash) 
+        nitro_options.override(:style, nitro_options.delete(:style).map do |key, value| 
+          "#{key.to_s.dasherize}: #{ value.is_a?(Integer) ? "#{value}px" : value };"
+        end.join(" "))
+      end
+    end
+
+    class NitroOptions
+      attr_reader :options
+      
+      def initialize(*options)
+        @options = merge(*options)
+      end
+
+      def merge(*options)
+        options.first
+      end
+
+      def default(*key_path, value)
+        modify_options(*key_path) { |memo, key| memo[key] = memo[key].nil? ? value : memo[key] }
+      end
+
+      def override(*key_path, value)
+        modify_options(*key_path) { |memo, key| memo[key] = value }
+      end
+
+      def concat(*key_path, value)
+        modify_options(*key_path) { |memo, key| memo[key] = [memo[key], value].compact.join(" ") }
+      end
+
+      def translate(*key_path) 
+        yield delete(*key_path) if exists?(*key_path)
+      end
+
+      def exists?(*key_path)
+        key_path.reduce(@options) { |memo, key| memo[key] }.present?
+      end
+
+      def [](key)
+        @options[key]
+      end
+
+      def delete(*key_path)
+        modify_options(*key_path) { |memo, key| memo.delete(key) }
+      end
+
+      private
+
+      # def get_item(key)
+
+      def modify_options(*key_path)
+        last_key = key_path.pop
+        nested_options = key_path.reduce(@options) { |memo, key| memo[key] ||= {} }
+        yield(nested_options, last_key)
+      end
+    end
+  end
+end

data/app/helpers/nitro_rails/nitro_tag_helper.rb

@@ -0,0 +1,183 @@
+module NitroRails
+  module NitroTagHelper 
+    def nitro_tag(tag = :div, text = nil, nitro_id: nil, link: nil, **options, &block)
+      nitro_options(options) do |options| 
+        options.default(:data, :nitro_id, nitro_id) if nitro_id
+      end
+
+      content_tag(tag, text, **options, &block)
+    end
+
+    ##########
+    ## BODY ##
+    ##########
+    
+    def nitro_body_tag(**options, &block) 
+      options.merge!(@custom_body_options) if @custom_body_options
+
+      nitro_options(options, @custom_body_options) do |options|
+        options.concat(:class, options.delete(:color_scheme) || current_color_scheme)
+        options.concat(:class, "#{controller_name}-#{action_name}")
+
+        if turbo_native_app?
+          options.concat(:class, "turbo-native")
+
+          if ios_app?
+            options.concat(:class, "ios")
+            options.override(:data, :turbo_native, "iOS")
+          elsif android_app?
+            options.concat(:class, "android")
+            options.override(:data, :turbo_native, "Android")
+          end
+        end
+
+        options.concat(:data, :controller, "panel-manager time-zone nitro")
+        options.concat(:data, :action, "turbo@morph->panel-manager#morph click->panel-manager#closeOtherPanels touchend->panel-manager#closeOtherPanels")
+        options.default(:data, :panel_manager_target, "container")
+        options.default(:data, :time_zone_server_time_value, "#{Time.now.utc.iso8601}")
+      end
+
+      content_tag(:body, **options, &block) # Should use nitro_tag
+    end
+
+    def body_options(**options)
+      @custom_body_options = options
+    end
+
+    ##########
+    ## LINK ##
+    ##########
+
+    def nitro_link_tag(*args, **options, &block)
+      nitro_options(options) do |options|
+        options.concat(:class, "nitro-link")
+        options.concat(:class, "active") if current_page?(args.last)
+      end
+
+      link_to(*args, **options, &block)
+    end
+
+    alias_method :nitro_link, :nitro_link_tag
+
+    ##############
+    ## RESOURCE ##
+    ##############
+    
+    def nitro_resource_tag(tag = :div, resource, **options, &block)
+      nitro_options(options) do |options|
+        options.default(:nitro_id, resource.nitro_id) # Maybe add default?
+        options.default(:data, :id, resource.id)
+        options.concat(:class, classify(resource.type))
+        options.concat(:class, resource_status_classes(resource))
+        options.concat(:class, "hover-context") unless options[:hover_context] == false
+
+        if link = options.delete(:link) 
+          options.default(:data, :action, "click->nitro#link")
+          options.default(:data, :nitro_link, link == true ? url_for(resource) : link)
+        end
+      end
+
+      with_nitro_resource(resource) do
+        nitro_tag(tag, **options, &block)
+      end
+    end
+
+    def nitro_resource(resource, **options, &block) 
+      nitro_resource_tag(options.delete(:tag) || :div, resource, **options, &block)
+    end
+
+    def with_nitro_resource(resource)
+      (@_nitro_resource_stack ||= []).push(resource)
+      yield
+    ensure
+      @_nitro_resource_stack.pop
+    end
+    
+    def current_nitro_resource
+      @_nitro_resource_stack&.last
+    end
+
+    ###############
+    ## ATTRIBUTE ##
+    ###############
+
+    def nitro_attribute_tag(tag_or_resource = :p, maybe_resource = current_nitro_resource, attribute, **options, &block)
+      # Not sure this works for all cases
+      # nitro_attribute_tag(:p, @task, :name, **options) 
+      # nitro_attribute_tag(@task, :name, **options)
+      # nitro_attribute_tag(:name, **options)
+      # nitro_attribute_tag(:p, :name, **options)
+      # 
+      ## First argument can be tag, resource, or attribute
+      ## Second argument can be resource or attribute
+      ## Third argument is always attribute
+      if tag_or_resource.is_a?(Symbol) || tag_or_resource.is_a?(String)
+        tag = tag_or_resource
+        resource = maybe_resource
+      else
+        tag = :p
+        resource = tag_or_resource
+      end
+
+      nitro_options(options) do |options|
+        options.default(:nitro_id, resource.nitro_id(attribute))
+        options.concat(:class, classify(attribute))
+        options.concat(:class, classify(resource.type, attribute))
+        options.concat(:class, attribute_status_class(resource, attribute))
+      end
+
+      # NEW CODE 
+      value = resource.send(attribute)
+
+      if options[:format] && value.present?
+        options.delete(:format).each do |method, params|
+          value = value.send(method, *params)
+        end
+      end
+
+      value = value.presence || options.delete(:default) || ""
+      # END NEW CODE
+
+      nitro_tag(tag, value, **options, &block)
+    end
+
+    def nitro_attribute(resource = current_nitro_resource, attribute, **options)
+      nitro_attribute_tag(options.delete(:tag) || :p, resource, attribute, **options)
+    end
+
+    private 
+
+    #############
+    ## HELPERS ##
+    #############
+
+    def resource_status_classes(resource)
+      classes = []
+      
+      resource.status_attributes.each do |attribute|
+        if resource.send(attribute).is_a?(TrueClass) || resource.send(attribute).is_a?(FalseClass)
+          classes.push("#{attribute}") if resource.send(attribute).is_a?(TrueClass)
+          classes.push("not-#{attribute}") if resource.send(attribute).is_a?(FalseClass)
+        elsif resource.class.defined_enums.key?(attribute.to_s)
+          classes.push("#{resource.send(attribute)}")
+        else 
+          classes.push("#{attribute}-#{resource.send(attribute)}")
+        end
+      end
+
+      classes.join(" ")
+    end
+
+    def attribute_status_class(resource, attribute)
+      if resource.send(attribute).is_a?(TrueClass) || resource.send(attribute).is_a?(FalseClass)
+        "#{resource.send(attribute)}"
+      else
+        "#{attribute}-#{resource.send(attribute)&.gsub(/ /, "-")}".downcase
+      end
+    end
+
+    def classify(*strings)
+      strings.join("-").dasherize
+    end
+  end
+end

data/app/helpers/nitro_rails/panel_helper.rb

@@ -0,0 +1,65 @@
+# Need to clean up this file.
+module NitroRails
+  module PanelHelper
+    def panel_frame_tag
+      render partial: "nitro_rails/panel_frame_tag", locals: { component_id: "nie" } # nie?
+    end
+
+    def panel_template 
+      render partial: "nitro_rails/panel_template"
+    end
+
+    def popup_panel_link(*args, **opts, &block)
+
+    end
+
+    def in_panel? 
+      request.headers['Turbo-Panel-Request'].present?
+    end
+
+    def panel_link(*args, **opts, &block)
+      if in_panel? 
+        return link_to(*args, **opts, &block)
+      end
+
+      opts[:data] ||= {}
+      opts[:data][:action] = "click->panel-manager#toggle"
+
+      if opts[:panel].is_a?(Hash) 
+        opts[:panel].each do |key, value|
+          opts[:data]["panel-#{key.to_s.dasherize}"] = value.to_s.dasherize
+        end
+      else 
+        opts[:data][:panel] = "default"
+      end
+
+      opts[:data][:panel_id] = "#{opts.to_s}#{args[-1].to_s}".hash
+
+      if opts[:panel] && opts[:panel][:presentation]
+        args[-1] = args[1] + "?presentation=#{opts[:panel][:presentation]}"
+      end
+
+      presentation = opts[:panel] && opts[:panel][:presentation] ? opts[:panel][:presentation] : "card"
+
+      container_opts = opts.delete(:container) || {}
+      container_opts[:class] ? container_opts[:class] += " panel-container #{presentation}" : container_opts[:class] = "panel-container #{presentation}"
+      
+      content_tag(:div, **container_opts) do
+        link_to(*args, **opts, &block)
+      end
+    end
+
+    class PanelLinkComponent 
+      def initialize(content = nil, path, **opts, &block)
+        @panel_options = opts.delete(:panel) || {}
+        @container_options = opts.delete(:container) || {}
+        @type = opts.delete(:type) || :card
+      end
+    end
+  end
+end
+
+# <a href="/path?ios-presentation=modal" data-panel-presentation="card" >
+#   ...
+# </a>
+# Could merge this and navigation helper methods into a single helper module

data/app/helpers/nitro_rails/resource_collection_helper.rb

@@ -0,0 +1,66 @@
+module NitroRails
+  module ResourceCollectionHelper
+    def resource_collection(*resources_or_path, **options, &block)
+      # signature = source_stamp.hash.abs.to_s(36)
+
+      if resources_or_path.last.is_a?(Symbol) 
+        resources_method = resources_or_path[-1]
+        resources_type = resources_method.to_s.singularize
+        resources_parent = resources_or_path[-2]
+        # resources_parent_type = resources_parent.type
+        resources_path = [resources_parent, resources_method]
+        resources = resources_parent.send(resources_method).where(options[:where])
+      else 
+        resources_type = resources_or_path.first.table.name.singularize
+        resources = resources_or_path.first
+      end
+      
+  
+      # binding.pry
+      ResourceCollection.new(resources, view: self, create_path: resources_path, parent: resources_parent, resource_type: resources_type, id: block.to_s.hash).render_content(&block)
+    end
+  end
+end
+
+
+  #   class ResourceCollection
+  #     attr_reader :controller, :parent, :resource_type
+
+  #     def initialize(controller, parent, resource_type)
+  #       @controller = controller
+  #       @parent = parent
+  #       @resource_type = resource_type
+  #     end
+
+  #     def main_classes 
+  #       @main_classes ||= "#{parent.type}-#{resource_type} #{parent.type}-#{resource_type}-list #{resource_type} #{resource_type}-list list list--arrow-detail list--basic-link"
+  #     end
+
+  #     def broadcast_tag
+  #       @broadcast_tag ||= "#{parent.resource_id}:#{resource_type}"
+  #     end
+
+  #     def resources
+  #       @resources ||= parent.send(resource_type)
+  #     end
+
+  #     def render(&block)
+  #       controller.render(layout: "aros/resource_collection", locals: { 
+  #         resource_type: resource_type,
+  #         classes: main_classes,
+  #         broadcast_tag: broadcast_tag,
+  #         resources: resources, 
+  #         resource_collection: self
+  #       }) do 
+  #         controller.capture(self, &block)
+  #       end
+  #     end
+
+  #     def render_items(**opts, &block) 
+  #       resources.order(opts[:order] || :created_at).each do |resource|
+  #         controller.concat(controller.capture(resource, &block))
+  #       end 
+  #     end
+  #   end
+
+# resource_type, classes, broadcast_tag, resources

data/app/helpers/nitro_rails/tabs_helper.rb

@@ -0,0 +1,51 @@
+module NitroRails
+  module TabsHelper 
+    def tabs_controller(**options, &block)
+      nitro_options(options) do |transformer|
+        transformer.concat(:class, "tabs-container")
+        transformer.concat(:data, :controller, "tabs")
+      end
+
+      content_tag(options.delete(:tag) || :div, **options, &block)
+    end
+
+    def tabs(**options, &block)
+      nitro_options(options) do |transformer|
+        transformer.concat(:class, "tabs")
+      end 
+
+      content_tag(options.delete(:tag) || :div, **options, &block)
+    end
+
+    def tab(screen, text = nil, **options, &block)
+      nitro_options(options) do |transformer|
+        transformer.concat(:class, "tab")
+        transformer.concat(:data, :action, "click->tabs#changeScreens")
+        transformer.concat(:data, :tabs_target, "tab")
+        transformer.concat(:data, :tabs_screen, screen.to_s)
+      end
+
+      content_tag(options.delete(:tag) || :button, text, **options, &block) 
+    end
+
+    def tab_screens(**options, &block)
+      nitro_options(options) do |transformer|
+        transformer.concat(:class, "tab-screens")
+        transformer.concat(:data, :tabs_target, "screens")
+      end
+
+      content_tag(options.delete(:tag) || :div, **options, &block)
+    end
+
+    def tab_screen(screen, content = nil, **options, &block)
+      nitro_options(options) do |transformer|
+        transformer.concat(:class, "tab-screen")
+        transformer.concat(:data, :tabs_target, "screen")
+        transformer.concat(:data, :tabs_screen, screen.to_s)
+        transformer.concat(:class, "hidden") unless options.delete(:visible)
+      end
+
+      content_tag(options.delete(:tag) || :div, content, **options, &block)
+    end
+  end
+end

data/app/helpers/nitro_rails/turbo_stream_helper.rb

@@ -0,0 +1,46 @@
+# I don't think this file is even being used (except for first two methods.)
+module NitroRails
+  module TurboStreamHelper
+    def private_stream_for(user, &block) 
+      turbo_stream_from user, &block
+    end
+
+    def public_stream(&block)
+      turbo_stream_from :public, &block
+    end
+
+    # METHODS BELOW ONLY NEEDED FOR VIEW/CONTROLLER STREAMS
+    # Is this necessary? Is any of this file for that matter?
+    def toggle_class(target, class_name, status:)
+      turbo_stream_action_tag :toggle_class, targets: target, class: class_name, status: status
+    end
+
+    # def render_errors(resource, authenticity_token)
+    #   if(resource.errors.any?)
+    #     resource.errors.attribute_names.map do |attribute|
+    #         turbo_stream_action_tag(:render_errors, 
+    #           authenticity_token: authenticity_token, 
+    #           attribute_id: attribute_id(resource, attribute),
+    #           error_message: resource.errors.full_messages_for(attribute).first, 
+    #           error_length: resource.errors[attribute].length, 
+    #         )
+    #     end.join.html_safe
+    #   end
+    # end
+
+    # def redirect(url)
+    #   turbo_stream_action_tag :redirect, url: url
+    # end
+
+    # def clear_errors(resource, authenticity_token) 
+    #   turbo_stream_action_tag :clear_errors, authenticity_token: authenticity_token
+    # end
+
+    # def attribute_id(resource, attribute) 
+    #   "#{resource.class.name.underscore}_#{resource.id}:#{attribute}"
+    # end
+  end
+end
+
+# Not sure this belongs in a helper, not sure any of this module does for that matter
+Turbo::Streams::TagBuilder.prepend(NitroRails::TurboStreamHelper)

data/app/lib/nitro_rails/local_time.rb

@@ -0,0 +1,51 @@
+module NitroRails
+  module LocalTime 
+    # def local_time(timezone)
+    # end
+
+    # def self.included(base)
+    #   base.extend(ClassMethods)
+    # end
+
+    # def timezone_accessor 
+    #   return @accessor if @accessor 
+    #   delegate = self.class.instance_variable_get(:@delegate)
+    #   if delegate 
+    #     @accessor = send(delegate)
+    #   else 
+    #     @accessor = self
+    #   end
+    # end
+
+    # def timezone_location 
+    #   timezone_accessor.timezone_location
+    # end
+
+    # module ClassMethods
+    #   def self.extended(base)
+    #     base.class_eval do
+    #       @delegate = self 
+    #     end
+    #   end
+      
+    #   def delegate_timezone_to(delegate)
+    #     @delegate = delegate
+    #   end
+
+    #   def timezone_accessor_methods
+    #     @timezone_accessor_methods ||= set_timezone_accessors
+    #   end
+      
+    #   def set_timezone_accessors(location: :timezone_location, short: :short_timezone, long: :long_timezone, offset: :utc_offset)
+    #     @timezone_accessor_methods = { 
+    #       timezone_location: location, 
+    #       short_timezone: short, 
+    #       long_timezone: long, 
+    #       utc_offset: offset 
+    #     }
+    #   end
+    # end
+  end
+end
+
+# delegate_timezone_to :settings

data/app/lib/nitro_rails/performable_routes.rb

@@ -0,0 +1,24 @@
+module NitroRails::PerformableRoutes
+  def performable(resource_name)
+    namespace = "sequence"
+    controller = "#{namespace}/#{resource_name}"
+
+    # Initiate (post)
+    post "#{resource_name}/initiate", to: "#{controller}#initiate", as: "initiate_#{resource_name.to_s.singularize}"
+    # Setup (get)
+    get "#{resource_name}/:id/setup", to: "#{controller}#setup", as: "setup_#{resource_name.to_s.singularize}"
+    # Start (post)
+    post "#{resource_name}/:id/start", to: "#{controller}#start", as: "start_#{resource_name.to_s.singularize}"
+    # Perform (get)
+    get "#{resource_name}/:id/perform", to: "#{controller}#perform", as: "perform_#{resource_name.to_s.singularize}"
+    get "#{resource_name}/:id/perform/:step", to: "#{controller}#perform", as: "perform_#{resource_name.to_s.singularize}_step"
+    # Next step (post)
+    post "#{resource_name}/:id/perform/:step/next", to: "#{controller}#next", as: "#{resource_name.to_s.singularize}_next_step"
+    # Back step (post)
+    post "#{resource_name}/:id/perform/:step/back", to: "#{controller}#back", as: "#{resource_name.to_s.singularize}_back_step"
+    # Complete (post)
+    post "#{resource_name}/:id/complete", to: "#{controller}#complete", as: "complete_#{resource_name.to_s.singularize}"
+    # Abandon (post)
+    post "#{resource_name}/:id/abandon", to: "#{controller}#abandon", as: "abandon_#{resource_name.to_s.singularize}"
+  end
+end