nitro_rails 0.1.0 → 0.1.1

data/app/lib/nitro_rails/resource_collection.rb

@@ -0,0 +1,183 @@
+class NitroRails::ResourceCollection 
+  delegate :content_tag, :concat, :capture, :form_tag, :hidden_field_tag, :render, :submit_tag, :turbo_stream_from, :request, :link_to, :url_for, to: :@view
+
+  # Should completely refigure what's passed in here
+  def initialize(resources, view:, create_path:, parent: nil, resource_type: nil, id: nil, signature: nil)
+    @resources = resources
+    @resource_path = create_path
+    @view = view
+    @parent = parent
+    @resource_type = resource_type if resource_type
+    @collection_tag = resource_type.pluralize if resource_type
+    # Little weird to override create path here
+    @create_path = (defined?(User) && @parent.is_a?(User)) ? @collection_tag : create_path
+    @id = id
+    @params = @view.params
+
+    if resources.first 
+      @collection_tag ||= resources.first.collection_tag # For list
+      @resource_type ||= resources.first.type # For list elements
+    end
+  end
+
+  # RENDERING METHODS
+
+  def render_content(&block)
+    # MAYBE - PASSED BLOCKS JUST DO A REFRESH OF THE COLLECTION, WHERE AS RENDERED PARTIALS DOES APPEND/REMOVE BROADCASTS (nitro_id: RESOURCES_ID_REFRESH, RESOURCE_ID_BROADCAST)
+    container_tag do 
+      concat(capture(self, &block)) if block_given?
+      concat(render_items) unless @resources_rendered
+    end
+  end
+
+  def container_tag(&block)
+    content_tag(:div, 
+    class: "resource-collection",
+    data: { 
+      controller: "resource-collection", 
+      action: "keydown->resource-collection#handleKeyDown" 
+    }, &block) 
+  end
+
+  def render_items(partial = nil, **opts, &block)
+    @resources_rendered = true
+    # set_order_info(opts[:order])
+
+    content_tag(:ul, id: @collection_tag, class: collection_classes(opts[:class]), data: { nitro_id: "#{nitro_id}" }) do 
+      @resources.order(opts[:order]).each do |resource|
+        concat(render_list_item(resource) do 
+          render_item(resource, partial, &block)
+        end)
+      end
+    end
+  end
+
+  # Do we need separate functions for item and list item?
+  def render_list_item(resource, &block)
+    content_tag(:li, class: "resource-collection-item list-item #{resource.type}", data: { id: resource.id, nitro_id: "#{resource.nitro_id}" }) do 
+      concat(capture(resource, &block))
+    end
+  end
+
+  def render_item(resource, partial, &block)
+    if block_given? 
+      # set_resource_collection_cache(&block)
+      capture(resource, &block)
+    else 
+      if partial.present?
+        render(partial, "#{resource.type}": resource)
+      else 
+        render resource
+      end
+    end
+  end
+
+  def new_resource_form(&block)
+    @form_rendered = true
+    form_tag(@create_path || "/#{@view.url_for(@collection_tag)}", method: :post, data: {
+      action: "ajax:success->resource-collection#handleSuccess" }) do # I hate the way we're setting the path here
+      concat(hidden_field_tag("#{@resource_type.singularize}[#{@parent.type.underscore}_id]", @parent.id)) # This definitely shouldn't be specific to projects
+      concat(capture(self, &block)) if block_given? 
+    end
+  end
+
+  def create_resource_button(text = nil, **opts, &block)
+    new_resource_form() do 
+      block_given? ? concat(content_tag(:button, class: "btn btn-create", type: "submit", data: { turbo: opts[:turbo] || false, "keyboard-target": "enter" }, &block)) : concat(submit_tag(text || "Create", class: "btn-new")) # This can be cleaned up
+    end
+  end
+
+  ###
+  # INFORMATION METHODS
+  
+  # Actually maybe split this so list classes are separate from container classes
+  def collection_classes(classes)
+    if @parent 
+      @collection_classes ||= "#{@parent.type}-#{@collection_tag} #{@parent.type}-#{@parent.id}-#{@collection_tag} #{@parent.type}-#{@collection_tag}-list #{@collection_tag} #{@collection_tag}-list list list--arrow-detail list--basic-link #{classes}"
+    else 
+      @collection_classes ||= "#{@collection_tag} #{@collection_tag}-list list list--arrow-detail list--basic-link #{classes}"
+    end
+  end
+
+  def nitro_id
+    @nitro_id ||= @parent ? "#{@parent.resource_id}:#{@collection_tag}" : "#{@collection_tag}"
+  end
+
+  ###
+  # ORDERING AND FILTERING METHODS
+  # Probably need to split these out into a separate module
+
+  def sorter(text, active_text=text, **opts)
+    if active_organizer(**opts)
+      link_to(active_text, current_path_without_order_params(**opts), class: "active", data: { turbo_action: :replace })
+    else 
+      link_to(text, current_path_with_new_order_params(**opts), class: "inactive", data: { turbo_action: :replace })
+    end
+  end
+
+  def active_organizer(**opts)
+    list_params && list_params[:order] && opts.all? do |key, val| 
+      list_params[:order][key].to_s == val.to_s
+    end
+  end
+
+  def filter(text, **opts) 
+    link_to(text, current_path_with_filter_params(**opts))
+  end
+
+  def current_path_with_new_order_params(**opts)
+    # current_params = request.query_parameters
+    # url_for(current_params.merge("#{@signature}" => { order: opts }))
+  end
+
+  def current_path_without_order_params(**opts)
+    # current_params = request.query_parameters.deep_dup 
+    # opts.each { |key, val| current_params["#{@signature}"][:order].delete("#{key}") }
+    # url_for(current_params)
+  end
+
+  def current_path_with_filter_params(**opts)
+    url_for("#{@signature}" => { filters: opts })
+  end
+
+  # def set_order_info(order_info = :created_at)
+  #   # Determine order direction and method from list_params if present
+  #   if list_params[:order]
+  #     @order_direction = list_params[:order].values.first == "asc" ? :asc : :desc
+  #     @order_method = list_params[:order].keys.first
+  #     @order = { @order_method => @order_direction }
+  #   else
+  #     # Set order information from the provided order_info
+  #     @order = order_info || :created_at
+      
+  #     case @order
+  #     when Symbol
+  #       @order_method = @order
+  #       @order_direction = :asc
+  #     when Hash
+  #       @order_method, @order_direction = @order.first
+  #     when Array
+  #       if @order[0].is_a?(Hash)
+  #         @order_method, @order_direction = @order[0].first
+  #       else
+  #         @order_method, @order_direction = @order
+  #       end
+  #     end
+  #   end
+  # end
+
+  private 
+
+  def list_params 
+    @list_params ||= @params.permit("#{@signature}": { order: @resources.sort_methods, filters: @resources.filter_methods})
+    @list_params["#{@signature}"] || {}
+  end
+end
+
+
+   # def render_list_item(resource, &block)
+  #   concat(render(layout: "aros/resource_collection_list_item", locals: { resource: resource }, &block))
+  # end
+# <%# content_tag(:li, id: dom_id(resource), class: "#{resource.type} #{resource.type}-item resource-collection-item", data: { nitro_id: resource.nitro_id }) do %>
+
+

data/app/lib/nitro_rails/sequential_routes.rb

@@ -0,0 +1,36 @@
+module NitroRails::SequentialRoutes
+  def sequence(domain, sequence_name, steps:)
+    controller = "#{domain}/#{sequence_name}_sequence"
+    collection_route = "#{domain}/#{sequence_name}"
+    individual_route = "#{domain}/:id/#{sequence_name}"
+    helper = "#{domain}_#{sequence_name}_sequence"
+
+    get collection_route, to: "#{controller}#start", as: helper
+    get "#{individual_route}/finish", to: "#{controller}#finish", as: "#{helper}_finish"
+    # get "#{individual_route}/:step", to: "#{controller}#step", as: "#{helper}_step"
+    # 
+    steps.each do |step|
+      get "#{individual_route}/#{step}", to: "#{controller}##{step}", as: "#{helper}_#{step}"
+      get "#{collection_route}/#{step}", to: "#{controller}##{step}", as: "new_#{helper}_#{step}"
+      patch "#{individual_route}/#{step}", to: "#{controller}##{step}!", as: "post_#{helper}_#{step}"
+      post "#{collection_route}/#{step}", to: "#{controller}##{step}!", as: "create_#{helper}_#{step}"
+      post "#{individual_route}/#{step}", to: "#{controller}##{step}!", as: "create_items_#{helper}_#{step}"
+    end
+  end
+
+  def sequence_controller(domain, sequence_name)
+    "sequences/#{domain}_#{sequence_name}"
+  end
+
+  def sequence_collection_route(domain, sequence_name)
+    "#{domain}/#{sequence_name}"
+  end
+
+  def sequence_individual_route(domain, sequence_name)
+    "#{domain}/:id/#{sequence_name}"
+  end
+
+  def sequence_helper(domain, sequence_name)
+    "#{domain}_#{sequence_name}_sequence"
+  end
+end

data/app/lib/nitro_rails/time_interval.rb

@@ -0,0 +1,88 @@
+class NitroRails::TimeInterval 
+  attr_accessor :started_at, :ended_at
+
+  def self.parse(string, date: Date.current, offset: 0)
+    if valid_time_interval_string?(string)
+      times = string.split("-").map do |time| 
+        time.to_time(:utc).change(
+          offset: offset, 
+          day: date.day, 
+          month: date.month, 
+          year: date.year
+        )
+      end
+
+      new(started_at: times.first, ended_at: times.first > times.last ? times.last + 1.day : times.last)
+    end
+	end
+
+  def self.valid_time_interval_string?(string)
+    string.match?(/\A\s*#{NitroRails::TimeString::TIME_INTERVAL_REGEX}\s*\z/)
+  end
+
+  def self.from(started_at, **options)
+    new(**options.merge(started_at: started_at))
+  end
+
+  def initialize(**attributes)
+    set(**attributes)
+  end
+
+  def change(**attributes)
+    set(**attributes)
+    reset_duration
+    return self
+  end
+
+  def from(time)
+    change(started_at: time)
+  end
+
+  def to(time)
+    change(ended_at: time)
+  end
+
+  def duration
+    @duration ||= ActiveSupport::Duration.build(ended_at - started_at)
+  end
+
+  def times 
+    [started_at, ended_at]
+  end
+
+  alias_method :to_a, :times 
+
+  def dates 
+    [started_at.to_date, ended_at.to_date]
+  end
+
+  def localtime(offset)
+    NitroRails::TimeInterval.new(
+      started_at: started_at.localtime(offset),
+      ended_at: ended_at.localtime(offset)
+    )
+  end
+
+  def to_fs(opt = :time, join: " - ")
+    times.map { |time| time.to_fs(opt) }.join(join)
+  end
+
+  def inspect 
+    to_fs(:db)
+  end
+
+  private 
+
+  def set(**attributes)
+    started_at = attributes[:started_at] || attributes[:from]
+    ended_at = attributes[:ended_at] || attributes[:to]
+
+    @started_at = started_at if started_at 
+    @ended_at = ended_at if ended_at 
+  end
+
+  def reset_duration
+    @duration = ActiveSupport::Duration.build(ended_at - started_at)
+  end
+end
+

data/app/lib/nitro_rails/time_string.rb

@@ -0,0 +1,22 @@
+module NitroRails::TimeString 
+  # REGULAR EXPRESSIONS
+  MINUTE_REGEX = /[0-5][0-9]/ # Matches 00 - 59
+
+  ## MILITARY TIME REGEX
+  MILITARY_HOUR_REGEX = /[0-1]?[0-9]|[2][0-3]/ # Matches 01-23
+  MILITARY_TIME_REGEX = /^\s*(#{MILITARY_HOUR_REGEX}):(#{MINUTE_REGEX})\s*$/
+
+  ## MERIDIEM TIME REGEX
+  MERIDIEM_HOUR_REGEX = /[0]?[1-9]|[1][0-2]/ # Matches 1-12
+  MERIDIEM_SUFFIX_REGEX = /[pPaA][.]?[mM][.]?/ # Matches 'a.m.' or 'PM'
+  POST_MERIDIEM_SUFFIX_REGEX = /[pP][.]?[mM][.]?/ # Matches just PM
+  MERIDIEM_TIME_REGEX = /(#{MERIDIEM_HOUR_REGEX}):(#{MINUTE_REGEX})\s*(#{MERIDIEM_SUFFIX_REGEX})/
+
+  ## ANY TIME 
+  TIME_REGEX = /(#{MERIDIEM_TIME_REGEX})|(#{MILITARY_TIME_REGEX})/
+
+  ## TIME INTERVAL STRING 
+  MERIDIEM_TIME_INTERVAL_REGEX = /(#{MERIDIEM_TIME_REGEX})\s*\-\s*(#{MERIDIEM_TIME_REGEX})/
+  MILITARY_TIME_INTERVAL_REGEX = /(#{MERIDIEM_TIME_REGEX})\s*\-\s*(#{MERIDIEM_TIME_REGEX})/
+  TIME_INTERVAL_REGEX = /(#{MERIDIEM_TIME_INTERVAL_REGEX})|(#{MILITARY_TIME_INTERVAL_REGEX})/
+end

data/app/models/nitro_rails/broadcast.rb

@@ -0,0 +1,76 @@
+module NitroRails
+  # Maybe call Stream instead of Broadcast
+  class Broadcast
+    include Turbo::Streams::Broadcasts
+
+    def self.build(*streamables, action, &block) 
+      new(*streamables, action).build(&block)
+    end
+
+    def build
+      yield(self)
+      return self
+    end
+
+    def initialize(streamables, action = nil)
+      @streamables = streamables
+      @action = action
+    end
+
+    def action(action)
+      @action = action
+    end
+
+    def attributes(**attributes)
+      @attributes = attributes
+    end
+
+    def target(target)
+      @target = "#{target}:not([data-reject-broadcasts])"
+    end
+
+    def targets(targets)
+      @targets = "#{targets}:not([data-reject-broadcasts])"
+    end
+
+    def template(content = nil, **rendering)
+      @template = content || render_format(:html, **rendering)
+    end
+            
+    def stream_attributes 
+      (@attributes || {}).merge(targets: @targets, target: @target, template: @template)
+    end
+
+    def stream 
+      turbo_stream_action_tag(@action, **stream_attributes)
+    end
+
+    def perform 
+      broadcast_stream_to(@streamables, content: stream)
+    end
+
+    def perform_later
+      broadcast_stream_later_to(@streamables, content: stream)
+    end
+
+    private
+      def render_format(format, **rendering)
+        ::ApplicationController.render(formats: [ format ], **rendering)
+      end
+  end 
+end
+
+
+module Turbo::Streams::Broadcasts
+  def broadcast_stream_later_to(*streamables, content:)
+    Turbo::Streams::StreamBroadcastJob.perform_later(*streamables, content: content)
+  end
+end
+
+class Turbo::Streams::StreamBroadcastJob < ActiveJob::Base
+  discard_on ActiveJob::DeserializationError
+
+  def perform(*streamables, content:)
+    Turbo::StreamsChannel.broadcast_stream_to streamables, content: content
+  end
+end

data/app/models/nitro_rails/broadcastable_model.rb

@@ -0,0 +1,91 @@
+module NitroRails
+  module BroadcastableModel
+
+    ## Default broadcasts
+
+    def use_default_broadcasts! 
+      broadcast_on_create :refresh_page, :focus_on_new_resource
+      broadcast_on_update :update_associated_attributes
+      broadcast_on_delete :remove_everywhere, :redirect_to_index
+    end
+
+    def use_refresh_broadcasts!
+      broadcast_on_create :refresh_page
+      broadcast_on_update :refresh_page
+      broadcast_on_delete :refresh_page
+    end
+
+    ## Action Broadcasts
+
+    def action_broadcasts(methods = {})
+      @action_broadcasts ||= methods
+    end
+
+    def broadcast_on_create(*methods)
+      broadcast_on_action(:create, *methods)
+    end
+
+    def broadcast_on_update(*methods)
+      broadcast_on_action(:update, *methods)
+    end
+
+    def broadcast_on_delete(*methods)
+      broadcast_on_action(:delete, *methods)
+    end
+
+    def broadcast_on_action(action, *methods)
+      if action_broadcasts[action].present?
+        action_broadcasts[action].concat(methods)
+      else 
+        action_broadcasts[action] = methods
+      end
+    end
+
+    def template 
+      new.template
+    end
+
+
+    ## Affiliations
+
+    def broadcast_affiliations(*affiliations) 
+      @affiliations ||= affiliations
+    end
+
+
+    ## Attribute Broadcasts
+
+    def broadcast_on_attribute(attribute, *methods)
+      attribute_broadcasts[attribute] = methods
+    end
+
+    def attribute_broadcasts(broadcasts = {})
+      @attribute_broadcasts ||= broadcasts
+    end
+
+    def skipped_attributes
+      @skipped_attributes ||= []
+    end
+
+    def skip_attribute_broadcasting(*attributes)
+      @skipped_attributes = attributes
+    end
+
+    ## Status Attributes
+    
+    def status_attributes(*attributes)
+      @status_attributes ||= attributes
+    end
+
+
+    ## Broadcast Identification
+
+    def type 
+      name.underscore
+    end
+  
+    def collection_tag
+      type.pluralize
+    end
+  end
+end

data/app/models/nitro_rails/broadcastable_record.rb

@@ -0,0 +1,118 @@
+module NitroRails
+  module BroadcastableRecord
+
+    include NitroRails::DefaultBroadcasts
+
+    ## Action Broadcasting 
+
+    def broadcast_create
+      broadcast(:create)
+    end
+
+    def broadcast_update
+      broadcast(:update)
+    end
+
+    def broadcast_delete
+      broadcast(:delete)
+    end
+
+    def broadcast(action)
+      self.class.action_broadcasts[action].to_a.each do |broadcast|
+        send(broadcast)
+      end
+    end
+
+
+    ## Attribute Broadcasting
+
+    def attribute_broadcasts
+      self.class.attribute_broadcasts
+    end
+
+    def skipped_attributes 
+      self.class.skipped_attributes
+    end
+
+    ## Status Attributes
+  
+    def status_attributes
+      self.class.status_attributes
+    end
+
+    def status_attribute?(attribute)
+      status_attributes.include?(attribute)
+    end
+
+    def attribute_effects(attribute) 
+      effects = ["replace_text", "replace_value", "replace_html"]
+      if status_attribute?(attribute)
+        if send(attribute).is_a?(TrueClass) || send(attribute).is_a?(FalseClass)
+          effects << "toggle_boolean_status_class"
+        else 
+          effects << "update_status_class"
+        end
+      end
+
+      return effects
+    end
+
+    def attribute_effects_string(attribute)
+      attribute_effects(attribute).join(" ").camelize(:lower)
+    end
+
+
+    ## Affiliations 
+
+    def affiliation_keys 
+      self.class.broadcast_affiliations
+    end
+
+    def affiliations 
+      affiliation_keys.map do |key|
+        send(key)
+      end.concat(belongs_to)
+    end
+    
+
+    ## Broadcast Identification
+     
+    def template 
+      @template ||= true 
+      return self
+    end
+
+    def template? 
+      @template
+    end
+
+    def type 
+      self.class.name.underscore
+    end
+
+    def collection_tag
+      type.pluralize
+    end
+  
+    def resource_id 
+      persisted? ? "#{type}_#{id}" : "#{type}_$#{temporary_id}"
+    end
+
+    def temporary_id
+      template? ? "template" : object_id
+    end
+
+    def nitro_id(*attributes)
+      [resource_id.dasherize, *attributes.compact].join(':')
+    end
+
+    def path_for_record
+      send("#{type}_path", self)
+    end
+
+    def belongs_to
+      self.class.reflect_on_all_associations(:belongs_to).map(&:name)
+    end
+
+  end
+end