nitro_rails 0.1.0 → 0.1.1

data/app/assets/stylesheets/nitro_rails/panels/popup-panel.css

@@ -0,0 +1,123 @@
+.panel-container.popup .panel-display {
+  width: 500px;
+  z-index: 100;
+  opacity: 1;
+  margin: 0 auto;
+  right: initial;
+  top: initial;
+  display: block;
+  height: 80vh;
+  max-height: 800px;
+  animation: slideUp ease-in-out 200ms 1 forwards;
+}
+
+@keyframes slideUp {
+  0% {
+    transform: translateY(8%);
+    opacity: 0;
+  }
+  100% {
+    transform: translateY(0);
+    opacity: 1;
+  }
+}
+
+
+.panel-container.popup .panel-display .content {
+  transition: background-color 1s;
+}
+
+
+.panel-container.popup .panel-display .content {
+  padding: 30px;
+}
+
+.panel-container.popup.active .panel-background {
+  background-color: rgba(0, 0, 0, 0.5);
+  /* add blur */
+  backdrop-filter: blur(10px);
+  -webkit-backdrop-filter: blur(10px);
+  position: fixed;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  overflow: hidden;
+  z-index: 10000;
+  align-items: center;
+  justify-content: center;
+  animation: overlayFadeIn ease-in-out 200ms 1 forwards;
+}
+
+@keyframes overlayFadeIn {
+  0% {
+    background-color: rgba(0, 0, 0, 0);
+    -webkit-backdrop-filter: blur(0);
+    backdrop-filter: blur(0);
+  }
+  100% {
+    background-color: rgba(0, 0, 0, 0.5);
+    -webkit-backdrop-filter: blur(10px);
+    backdrop-filter: blur(10px);
+  }
+}
+
+/* html:has(.panel-container.popup.active) {
+  overflow: hidden !important;
+} */
+
+
+/* TODO - Review Code Below */
+
+.panel-container.popup .panel.hidden .panel-background {
+  background-color: rgba(0, 0, 0, 0);
+  -webkit-backdrop-filter: blur(0);
+  backdrop-filter: blur(0);
+  position: fixed;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  overflow: hidden;
+  z-index: 10000;
+  align-items: center;
+  justify-content: center;
+  animation: overlayFadeOut ease-in-out 200ms 1 forwards;
+}
+
+@keyframes overlayFadeOut {
+  0% {
+    background-color: rgba(0, 0, 0, 0.5);
+    -webkit-backdrop-filter: blur(10px);
+    backdrop-filter: blur(10px);
+  }
+  99% {
+    background-color: rgba(0, 0, 0, 0);
+    -webkit-backdrop-filter: blur(0);
+    backdrop-filter: blur(0);
+  }
+  100% {
+    display: none;
+    position: relative;
+  }
+}
+
+.panel-container.popup .panel.hidden {
+  display: block !important;
+}
+
+.panel-container.popup .panel.hidden .panel-display {
+  animation: slideDown ease-in-out 200ms 1 forwards;
+}
+
+@keyframes slideDown {
+  0% {
+    transform: translateY(0);
+    opacity: 1;
+  }
+  100% {
+    transform: translateY(8%);
+    opacity: 0;
+    display: none;
+  }
+}

data/app/controllers/nitro_rails/sequence_controller.rb

@@ -0,0 +1,64 @@
+module NitroRails
+  class SequenceController < ActionController::Base
+    layout 'application'
+    
+    before_action :set_sequence
+
+    helper_method :next_step_in_sequence_path, :previous_step_in_sequence_path, :first_step_in_sequence_path, :last_step_in_sequence_path
+
+    def self.sequence(*steps) 
+      @sequence = [:start, *steps, :finish]
+    end
+
+    def self.before_each_step(action)
+      before_action action, only: [:step, :finish]
+    end
+
+    def self.get_step_for(step)
+      return @sequence[step]
+    end
+
+    def redirect_to_step(step)
+      redirect_to self.class.get_step_for(step)
+    end
+
+    # Convenience Methods 
+
+    def next_step_in_sequence_path(id = nil)
+      # binding.pry
+      url_for(request.params.slice(:controller).merge(action: @sequence[:next_step], id: id)) if @sequence[:next_step]
+    end
+
+    def previous_step_in_sequence_path
+      url_for(request.params.slice(:controller).merge(action: @sequence[:previous_step])) if @sequence[:previous_step]
+    end
+
+    def first_step_in_sequence_path(resource = nil)
+      url_for(request.params.slice(:controller).merge(action: @sequence[:first_step])) if @sequence[:first_step]
+    end
+
+    def last_step_in_sequence_path
+      url_for(request.params.slice(:controller).merge(action: @sequence[:last_step])) if @sequence[:last_step]
+    end
+
+    # Initialization Information
+    # 
+    def start 
+      redirect_to next_step_in_sequence_path
+    end
+
+    def set_sequence 
+      steps = self.class.instance_variable_get(:@sequence)
+      current_step_index = steps.index(params[:action].gsub(/!/, "").to_sym)
+
+      @sequence = {
+        steps: steps,
+        first_step: steps[0],
+        previous_step: current_step_index <= 1 ? nil : steps[current_step_index - 1],
+        current_step: steps[current_step_index],
+        next_step: steps[current_step_index + 1],
+        last_step: steps[-1],
+      }
+    end
+  end
+end

data/app/helpers/nitro_rails/application_helper.rb

@@ -1,4 +1,45 @@
 module NitroRails
   module ApplicationHelper
+    def alert_message(message, threat=:notice) 
+      content_tag(:div, message, class: "alert #{threat}")
+    end
+
+    def current_color_scheme
+      current_user && current_user.respond_to?(:settings) && current_user.settings.dark_mode? ? "dark-mode" : "light-mode"
+    end
+
+    def back_path(default = root_path)
+      params[:referrer] || default # Should we add in :back?
+    end
+
+    def polymorphize(record, polymorphic_type)
+      { "#{polymorphic_type}_id": record.id, "#{polymorphic_type}_type": record.class.name }
+    end
+
+    def contextual_day_format(date, offset: 0) 
+      relative_date = Time.current.in_time_zone(offset).to_date
+      case (relative_date - date).to_i 
+      when 0...1
+        "Today"
+      when 1...2
+        "Yesterday"
+      when 2...7
+        date.to_fs(:weekday)
+      else 
+        if (relative_date.year == date.year)
+          date.to_fs(:month_and_day)
+        else 
+          date.to_fs(:month_day_and_year)
+        end
+      end
+    end
+
+    def ios_app?
+      request.user_agent&.include?("iOS")
+    end
+
+    def android_app?
+      request.user_agent&.include?("Android")
+    end
   end
-end
+end

data/app/helpers/nitro_rails/color_helper.rb

@@ -0,0 +1,23 @@
+module NitroRails
+  module ColorHelper
+    def brightness_indicator(color)
+      case brightness(color)
+      when 0..100
+        "dark"
+      when 101..200
+        "medium"
+      else
+        "light"
+      end
+    end
+
+    def brightness(color)
+      if color&.start_with?("#")
+        r = color[1..2].to_i(16)
+        g = color[3..4].to_i(16)
+        b = color[5..6].to_i(16)
+        (r * 299 + g * 587 + b * 114) / 1000
+      end
+    end
+  end
+end

data/app/helpers/nitro_rails/components_helper.rb

@@ -0,0 +1,49 @@
+module NitroRails
+  module ComponentsHelper
+    def inline_svg(path, **options)
+      nitro_options(options) do |options|
+        options.concat(:class, "inline-svg")
+        options.concat(:class, "svg-#{path.split("/").last}")
+        options.concat(:class, options.delete(:size))
+        options.concat(:style, "transform: rotate(#{options.delete(:rotate)}deg);") if options[:rotate]
+      end
+
+      # Rails.cache.clear
+      svg = Rails.cache.fetch("inline_svg/#{path}", expires_in: 12.hours) do
+        app_path = Rails.root.join("app/assets/images/svgs/#{path}.svg")
+        gem_path = NitroRails::Engine.root.join("app/assets/images/nitro_rails/#{path}.svg")
+
+        if File.exist?(app_path)
+          File.read(app_path).html_safe
+        elsif File.exist?(gem_path)
+          File.read(gem_path).html_safe
+        else
+          "(SVG file not found: #{path})"
+        end
+      end
+      
+      content_tag(:div, **options) do 
+        render inline: svg
+      end
+    end
+    
+    def clock 
+      content_tag(:div, class: "clock", data: { controller: "clock" }) do
+        content_tag(:span, Time.now.strftime("%-I:%M %p"), class: "clock-time", data: { "clock-target": "time" }) 
+      end
+    end
+
+    def search_bar(**options)
+      options[:class] = "search-bar #{options[:class]}"
+      options[:data] ||= {}
+      options[:data][:controller] = "search"
+
+      content_tag(:div, **options) do 
+        content_tag(:i, "", class: "fas fa-search") +
+        form_with(url: '/', method: :get, data: { turbo: false }) do 
+          text_field_tag(:query, params[:query], class: "search-bar-input", placeholder: "Search", data: { action: "keyup->search#search" })
+        end
+      end
+    end
+  end
+end

data/app/helpers/nitro_rails/inline_edit_helper.rb

@@ -0,0 +1,48 @@
+module NitroRails
+  module InlineEditHelper
+    def editable_text(resource_path, attribute, context: :broadcast, placeholder: nil, focus: false, tag: :p)
+      render partial: 'nitro_rails/editable_text', locals: { 
+        resource_path: resource_path, 
+        resource: resource_path.is_a?(Array) ? resource_path.last : resource_path,
+        attribute: attribute, 
+        context: context, 
+        placeholder: placeholder, 
+        focus: focus, 
+        tag: tag
+      }
+    end
+
+    def togglable_checkbox(resource_path, attribute, context: :broadcast)
+      render partial: 'nitro_rails/togglable_checkbox', locals: {
+        resource_path: resource_path,
+        resource: resource = resource_path.is_a?(Array) ? resource_path.last : resource_path,
+        attribute: attribute,
+        context: context
+      }
+    end
+
+    def updatable_text(resource, attribute, placeholder: nil)
+      content_tag(:span, resource.send(attribute).presence, class: "updatable-text", placeholder: placeholder, data: { 
+        nitro_id: resource.nitro_id(attribute)
+      })
+    end
+  
+    def error_badge(resource, attribute)
+      error_count = resource.errors[attribute].length
+      content_tag(:span, error_count, class: "error-badge #{'visible' if error_count > 0}", data: { 
+        attribute_error_count_id: resource.nitro_id(attribute)
+      })
+    end
+  
+    def error_message(resource, attribute)
+      error_message = resource.errors.full_messages_for(attribute).first
+      content_tag(:span, error_message, class: "error-message #{'visible' if error_message}", data: { 
+        attribute_error_message_id: resource.nitro_id(attribute) 
+      })
+    end
+
+    def attribute_classes(resource, attribute) 
+      "#{resource.class.name.downcase.dasherize}-#{attribute} #{resource.class.name.downcase.dasherize}-#{resource.id}-#{attribute} #{attribute}"
+    end
+  end
+end

data/app/helpers/nitro_rails/nitro_action_helper.rb

@@ -0,0 +1,178 @@
+module NitroRails
+  module NitroActionHelper 
+    def nitro_action_form(**options, &block)
+      nitro_hidden_action_form(**options) do |form|
+        form.submit_div(&block)
+      end
+    end
+
+    def nitro_action_button(text, **options, &block)
+      text ||= "Save" if !block_given?
+
+      nitro_hidden_action_form(**options) do |form|
+        form.submit(text, &block)
+      end
+    end
+
+    def nitro_hidden_action_form(**options, &block)
+      nitro_form(**options) do |form| 
+        concat(form.generate_hidden_attribute_fields)
+        concat(yield(form))
+      end
+    end
+
+    ############
+    ## CREATE ##
+    ############
+
+    def nitro_create(type, **options, &block)
+      nitro_create_options(type, options)
+      nitro_action_form(**options, &block)
+    end
+
+    def nitro_create_button(text=nil, type, **options, &block)
+      nitro_create_options(type, options)
+      nitro_action_button(text, **options, &block)
+    end
+
+    def nitro_create_options(type, options)
+      nitro_options(options) do |options|
+        options.default(:method, :post)
+        options.default(:model, type.to_s.classify.constantize.new)
+        options.default(:params, type.to_sym => options.delete(:params) || {})
+      end
+    end
+
+    ##########
+    ## SAVE ##
+    ##########
+    
+    def nitro_save(resource = current_nitro_resource, **options, &block)
+      nitro_save_options(resource, options)
+      nitro_action_form(**options, &block)
+    end
+    
+    # No idea if any of the buttons are working
+    def nitro_save_button(text_or_resource = nil, maybe_resource = current_nitro_resource, **options, &block)
+      resource, text = button_args(text_or_resource, maybe_resource)
+      nitro_save_options(resource, options)
+      nitro_action_button(text, **options, &block)
+    end
+
+
+    def nitro_save_options(resource, options)
+      nitro_options(options) do |options|
+        options.default(:method, resource.persisted? ? :patch : :post)
+        options.default(:model, resource)
+        options.default(:params, resource.type.to_sym => options.delete(:params) || {})
+      end
+    end
+
+    ############
+    ## UPDATE ##
+    ############
+
+    def nitro_update(resource = current_nitro_resource, **options, &block)
+      nitro_update_options(resource, options)
+      nitro_action_form(**options, &block)
+    end
+
+    def nitro_update_button(text_or_resource = nil, maybe_resource = current_nitro_resource, **options, &block)
+      resource, text = button_args(text_or_resource, maybe_resource)
+      nitro_update_options(resource, options)
+      nitro_action_button(text, **options, &block)
+    end
+
+    def nitro_update_options(resource, options)
+      nitro_options(options) do |options|
+        options.default(:method, :patch)
+        options.default(:model, resource)
+        options.default(:params, resource.type.to_sym => options.delete(:params) || {})
+      end
+    end
+
+    #############
+    ## DESTROY ##
+    #############
+
+    def nitro_destroy(resource = current_nitro_resource, **options, &block)
+      nitro_destroy_options(resource, options)
+      nitro_action_form(**options, &block)
+    end
+
+    def nitro_destroy_button(text_or_resource = nil, maybe_resource = current_nitro_resource, **options, &block)
+      resource, text = button_args(text_or_resource, maybe_resource)
+      nitro_destroy_options(resource, options)
+      nitro_action_button(text, **options, &block)
+    end
+
+    def nitro_destroy_options(resource, options)
+      nitro_options(options) do |options|
+        options.default(:method, :delete)
+        options.default(:model, resource)
+      end
+    end
+
+    private 
+
+    #############
+    ## HELPERS ##
+    #############
+
+    # Refactor at some point
+    def button_args(*args)
+      if args.length > 3
+        raise ArgumentError, "Too many arguments. Expected 0, 1, or 2 arguments."
+      end
+
+      if args.first == nil || args.first.is_a?(String) || args.first.is_a?(Symbol)
+        return [args.last, args.first]
+      end
+
+      if args.first.is_a?(ActiveRecord::Base)
+        return [args.first, nil]
+      end
+    end
+  end
+end
+
+###########
+## STASH ##
+###########
+
+# def nitro_create_button(text=nil, record_type, **opts, &block) 
+#   options = { method: :post, data: { turbo: true, controller: "nitro", action: "nitro#insertNewItem" }}.merge(opts.delete(:options).to_h)
+#   params = { params: { record_type.to_sym => opts } }
+#   path = record_type.to_s.pluralize.to_sym
+
+#   forges = opts[:forges].is_a?(Array) ? opts[:forges] : [opts[:forges]].compact
+  
+
+#   content_tag(:div, class: "nitro-form-stack") do 
+#     forges.each do |forger|
+#       concat(forger_form(forger)) unless forger.persisted?
+#     end
+
+#     if block_given? 
+#       concat(button_to(path, options.merge(params), &block))
+#     else 
+#       concat(button_to(text || "Create #{record_type}", path, options.merge(params)))
+#     end
+#   end
+# end
+# 
+# def forger_form(forger)
+#   nitro_hidden_resource_form(forger) {}
+# end
+#
+# def harvest_arguments(arguments, keys)
+#   output = []
+#   arguments.each_with_index do |argument, index|
+#     if keys[index] == :text? && (argument.is_a?(String) || argument.is_a?(Symbol)) || argument.nil?
+#       output << argument 
+#     else 
+#       output << arg
+      
+#     end
+#   end
+# end

data/app/helpers/nitro_rails/nitro_collection_helper.rb

@@ -0,0 +1,87 @@
+module NitroRails
+  module NitroCollectionHelper
+    def nitro_collection_tag(tag = :ul, parent, resource_method, **options, &block)
+      nitro_options(options) do |options|
+        options.default(:nitro_id, parent.nitro_id(resource_method))
+        options.concat(:class, classify(resource_method))
+        options.concat(:class, classify(parent.type, resource_method))
+      end
+
+      nitro_tag(tag, **options, &block)
+    end
+
+    def nitro_collection(parent, resource_method, **options, &block)
+      content_tag(:div, data: { controller: "nitro-collection", nitro_collection_target: "container", nitro_collection_id: "#{parent.nitro_id}:#{resource_method}" }) do
+        nitro_collection_tag(:ul, parent, resource_method, data: { nitro_collection_target: :collection }, **options) do 
+          resources = parent.send(resource_method)
+          resources = resources.order(options.delete(:order)) if options[:order]
+          resources = resources.where(options.delete(:where)) if options[:where]
+          resources = resources.take(options.delete(:take)) if options[:take]
+          
+
+          resources.map do |resource|
+            yield resource
+          end
+        end + 
+
+        content_tag(:template, class: "nitro-collection-template", style: "display: none;", data: { nitro_collection_target: :template }) do
+          yield parent.send(resource_method).template
+        end 
+      end
+    end
+
+    def chain_methods(*array)
+      array.inject { |obj, method| obj.public_send(method) }
+    end
+
+    def new_nitro_collection(*resources_or_path, **options, &block)
+      resources = is_active_collection?(resources_or_path.first) ? resources_or_path.first : chain_methods(*resources_or_path)
+      NitroCollection.new(resources, view: self, **options).render_content(&block)
+    end
+    
+    def is_active_collection?(collection)
+      collection.is_a?(ActiveRecord::Associations::CollectionProxy || ActiveRecord::Relation)
+    end
+  end 
+end
+
+
+# resources: collection_proxy,
+# resource_type: collection_proxy.proxy_association.reflection.klass.name.underscore,
+# parent: collection_proxy.proxy_association.owner,
+# where_clause: collection_proxy.where_clause,
+# order_clause: collection_proxy.order_values,
+# request_hash: collection_proxy.to_sql.hash
+
+
+# class NitroCollection 
+#   def initialize(**options)
+#     @parent = options[:affiliation]
+#     @method = options[:method]
+#     @order = options[:order]
+#     @resources = @parent.send(@method).order(options[:order])
+#     @type = options[:type] || @resources.first.class.name.underscore
+#     @method = method
+#   end
+
+#   def render_content(&block)
+    
+#   end
+# end
+
+# def nitro_collection(tag = :ul, parent, resource_method, **options, &block)
+#   content_tag(:div, class: "nitro-collection-container") do
+#     nitro_collection_tag(tag, parent, resource_method, **options) do 
+#       parent.send(resource_method).order(options[:order]).map do |resource|
+#         yield resource
+#       end
+#     end + 
+
+#     content_tag(:template, class: "nitro-collection-template", style: "display: none;") do
+#       yield parent.send(resource_method).template
+#     end
+#   end
+# end
+
+# private?
+# NitroCollection.new(affiliation: @day, method: :tasks, order: :created_at)

data/app/helpers/nitro_rails/nitro_edit_helper.rb

@@ -0,0 +1,15 @@
+module NitroRails
+  module NitroEditHelper 
+    def nitro_checkbox(record, attribute, **options) 
+      nitro_options(options) do |options|
+        options.default(:method, :patch)
+        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, record.nitro_id)
+      end
+
+      render partial: 'nitro_rails/nitro_checkbox', locals: { record: record, attribute: attribute, options: options }
+    end
+  end
+end