joys 0.1.1 → 0.1.3

data/lib/joys/styles.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+# lib/joys/styles.rb - Simplified Component Styling
+require 'fileutils'
+require 'set'
+module Joys
+  module Styles
+    def self.compile_component_styles(comp_name, base_css, media_queries, scoped)
+      scope_prefix = scoped ? ".#{comp_name.tr('_', '-')} " : ""
+      processed_base_css = base_css.map { |css| scope_css(css, scope_prefix) }
+      processed_media_queries = {}
+      
+      # FIX: Actually iterate over the media_queries parameter
+      media_queries.each do |key, css_rules|
+        scoped_rules = css_rules.map { |css| scope_css(css, scope_prefix) }
+        processed_media_queries[key] = scoped_rules
+      end
+      
+      Joys.compiled_styles[comp_name] = {
+        base_css: processed_base_css,
+        media_queries: processed_media_queries,
+        container_queries: {} # Keep this for compatibility, but media_queries contains all now
+      }.freeze
+    end
+    
+    private
+    
+    def self.render_consolidated_styles(used_components)
+      return "" if used_components.empty?
+      cache_key = used_components.to_a.sort.join(',')
+      return Joys.consolidated_cache[cache_key] if Joys.consolidated_cache.key?(cache_key)
+      buffer = String.new(capacity: 4096)
+      min_queries = Hash.new { |h,k| h[k] = [] }
+      max_queries = Hash.new { |h,k| h[k] = [] }
+      minmax_queries = []
+      container_min_queries = Hash.new { |h,k| h[k] = [] }
+      container_max_queries = Hash.new { |h,k| h[k] = [] }
+      container_minmax_queries = []
+      container_named_queries = Hash.new { |h,k| h[k] = {min: Hash.new { |h,k| h[k] = [] }, max: Hash.new { |h,k| h[k] = [] }, minmax: []} }
+      seen_base = Set.new
+      
+      used_components.each do |comp|
+        styles = Joys.compiled_styles[comp] || next
+        styles[:base_css].each do |rule|
+          next if seen_base.include?(rule)
+          buffer << rule
+          seen_base << rule
+        end
+        styles[:media_queries].each do |key, rules|
+          case key
+          # FIX: Updated regex patterns to match the actual key formats
+          when /^m-min-(\d+)$/
+            min_queries[$1.to_i].concat(rules)
+          when /^m-max-(\d+)$/
+            max_queries[$1.to_i].concat(rules)
+          when /^m-minmax-(\d+)-(\d+)$/
+            minmax_queries << { min: $1.to_i, max: $2.to_i, css: rules }
+          when /^c-min-(\d+)$/
+            container_min_queries[$1.to_i].concat(rules)
+          when /^c-max-(\d+)$/
+            container_max_queries[$1.to_i].concat(rules)
+          when /^c-minmax-(\d+)-(\d+)$/
+            container_minmax_queries << { min: $1.to_i, max: $2.to_i, css: rules }
+          when /^c-([^-]+)-min-(\d+)$/
+            name, size = $1, $2.to_i
+            container_named_queries[name][:min][size].concat(rules)
+          when /^c-([^-]+)-max-(\d+)$/
+            name, size = $1, $2.to_i
+            container_named_queries[name][:max][size].concat(rules)
+          when /^c-([^-]+)-minmax-(\d+)-(\d+)$/
+            name, min_size, max_size = $1, $2.to_i, $3.to_i
+            container_named_queries[name][:minmax] << { min: min_size, max: max_size, css: rules }
+          end
+        end
+      end
+      
+      max_queries.sort.reverse.each do |bp, rules|
+        buffer << "@media (max-width: #{bp}px){"
+        rules.uniq.each { |r| buffer << r }
+        buffer << "}"
+      end
+      min_queries.sort.each do |bp, rules|
+        buffer << "@media (min-width: #{bp}px){"
+        rules.uniq.each { |r| buffer << r }
+        buffer << "}"
+      end
+      minmax_queries.sort_by { |q| [q[:min], q[:max]] }.each do |q|
+        buffer << "@media (min-width: #{q[:min]}px) and (max-width: #{q[:max]}px){"
+        q[:css].uniq.each { |r| buffer << r }
+        buffer << "}"
+      end
+      container_max_queries.sort.reverse.each do |size, rules|
+        buffer << "@container (max-width: #{size}px){"
+        rules.uniq.each { |r| buffer << r }
+        buffer << "}"
+      end
+      container_min_queries.sort.each do |size, rules|
+        buffer << "@container (min-width: #{size}px){"
+        rules.uniq.each { |r| buffer << r }
+        buffer << "}"
+      end
+      container_minmax_queries.sort_by { |q| [q[:min], q[:max]] }.each do |q|
+        buffer << "@container (min-width: #{q[:min]}px) and (max-width: #{q[:max]}px){"
+        q[:css].uniq.each { |r| buffer << r }
+        buffer << "}"
+      end
+      container_named_queries.each do |name, queries|
+        queries[:max].sort.reverse.each do |size, rules|
+          buffer << "@container #{name} (max-width: #{size}px){"
+          rules.uniq.each { |r| buffer << r }
+          buffer << "}"
+        end
+        queries[:min].sort.each do |size, rules|
+          buffer << "@container #{name} (min-width: #{size}px){"
+          rules.uniq.each { |r| buffer << r }
+          buffer << "}"
+        end
+        queries[:minmax].sort_by { |q| [q[:min], q[:max]] }.each do |q|
+          buffer << "@container #{name} (min-width: #{q[:min]}px) and (max-width: #{q[:max]}px){"
+          q[:css].uniq.each { |r| buffer << r }
+          buffer << "}"
+        end
+      end
+      buffer.freeze.tap { |css| Joys.consolidated_cache[cache_key] = css }
+    end
+    
+    def self.render_external_styles(used_components)
+      return "" if used_components.empty?
+      cache_key = used_components.to_a.sort.join(',')
+      css_filename = "#{cache_key}.css"
+      #css_filename = "#{Digest::SHA256.hexdigest(cache_key)[0..12]}.css"
+      css_path = Joys.css_path || "public/css"
+      full_path = File.join(css_path, css_filename)
+      FileUtils.mkdir_p(css_path)
+      unless File.exist?(full_path)
+        css_content = render_consolidated_styles(used_components)
+        File.write(full_path, css_content)
+      end
+      "<link rel=\"stylesheet\" href=\"/css/#{css_filename}\">"
+    end
+    
+    def self.scope_css(css, scope_prefix)
+      return css if scope_prefix.empty?
+      selectors = css.split(',')
+      scoped_selectors = selectors.map do |selector|
+        selector.strip!
+        if match = selector.match(/^\s*\.([a-zA-Z][\w-]*)/)
+        #if selector.match(/^\s*\.([a-zA-Z][\w-]*)/)
+          "#{scope_prefix}#{selector}"
+        else
+          selector
+        end
+      end
+      scoped_selectors.join(', ')
+    end
+  end
+end

data/lib/joys/tags.rb

@@ -0,0 +1,124 @@
+# lib/joys/tags.rb
+require_relative "hugdown"
+module Joys
+  module Tags
+    VOID_TAGS = %w[area base br col embed hr img input link meta param source track wbr].freeze
+    TAGS = %w[
+      a abbr address article aside audio b bdi bdo blockquote body button canvas
+      caption cite code colgroup data datalist dd del details dfn dialog div dl dt
+      em fieldset figcaption figure footer form h1 h2 h3 h4 h5 h6 head header hgroup
+      html i iframe ins kbd label legend li main map mark menu meter nav noscript
+      object ol optgroup option output p picture pre progress q rp rt ruby s samp
+      script section select small span strong style sub summary sup table tbody td
+      template textarea tfoot th thead time title tr u ul var video
+    ].freeze
+    BOOLEAN_ATTRS = %w[
+      disabled readonly read_only multiple checked selected 
+      auto_focus autofocus no_validate novalidate form_novalidate formnovalidate
+      hidden required open reversed scoped seamless muted auto_play autoplay 
+      controls loop default inert item_scope itemscope
+    ].to_set.freeze
+    
+    CLS = ' class="'.freeze
+    QUO = '"'.freeze
+    BC = '>'.freeze
+    BO = '<'.freeze
+    GTS = '</'.freeze
+    EQ = '="'.freeze
+    
+    VOID_TAGS.each do |tag|
+      define_method(tag) do |cs: nil, **attrs|
+        class_string = case cs
+        when String, Symbol then cs.to_s
+        when Array then cs.compact.reject { |c| c == false }.map(&:to_s).join(" ")
+        else ""
+        end
+        
+        @bf << BO << tag
+        @bf << CLS << class_string << QUO unless class_string.empty?
+        
+        attrs.each do |k, v|
+          key = k.to_s
+          
+          if v.is_a?(Hash) && (key == "data" || key.start_with?("aria"))
+            prefix = key.tr('_', '-')
+            v.each do |sk, sv|
+              next if sv.nil? || sv == false  # Skip nil and boolean false
+              attr_name = "#{prefix}-#{sk.to_s.tr('_', '-')}"
+              @bf << " #{attr_name}#{EQ}#{CGI.escapeHTML(sv.to_s)}#{QUO}"
+            end
+          else
+            next if v.nil?
+            
+            if BOOLEAN_ATTRS.include?(key)
+              @bf << " #{key.tr('_', '')}" if v
+            elsif v == false
+              next
+            else
+              attr_name = key.tr('_', '-')
+              @bf << " #{attr_name}#{EQ}#{CGI.escapeHTML(v.to_s)}#{QUO}"
+            end
+          end
+        end
+        
+        @bf << BC
+        nil
+      end
+    end
+    
+    TAGS.each do |tag|
+      define_method(tag) do |content = nil, cs: nil, raw: false, **attrs, &block|
+        class_string = case cs
+        when String, Symbol then cs.to_s
+        when Array then cs.compact.reject { |c| c == false }.map(&:to_s).join(" ")
+        else ""
+        end
+        
+        @bf << BO << tag
+        @bf << CLS << class_string << QUO unless class_string.empty?
+        
+        attrs.each do |k, v|
+          key = k.to_s
+          
+          if v.is_a?(Hash) && (key == "data" || key.start_with?("aria"))
+            prefix = key.tr('_', '-')
+            v.each do |sk, sv|
+              next if sv.nil? || sv == false  # Skip nil and boolean false
+              attr_name = "#{prefix}-#{sk.to_s.tr('_', '-')}"
+              @bf << " #{attr_name}#{EQ}#{CGI.escapeHTML(sv.to_s)}#{QUO}"
+            end
+          else
+            next if v.nil?
+            
+            if BOOLEAN_ATTRS.include?(key)
+              @bf << " #{key.tr('_', '')}" if v
+            elsif v == false
+              next
+            else
+              attr_name = key.tr('_', '-')
+              @bf << " #{attr_name}#{EQ}#{CGI.escapeHTML(v.to_s)}#{QUO}"
+            end
+          end
+        end
+        
+        @bf << BC
+        
+        if block
+          instance_eval(&block)
+        elsif content
+          @bf << (raw ? content.to_s : CGI.escapeHTML(content.to_s))
+        end
+        
+        @bf << GTS << tag << BC
+        nil
+      end
+      define_method("#{tag}!") do |content = nil, cs: nil, **attrs, &block|
+        send(tag, content, cs: cs, raw: true, **attrs, &block)
+      end
+      define_method("#{tag}?") do |content = nil, cs: nil, **attrs, &block|
+        parsed_content = Joys::Config.markup_parser.call(content.to_s)
+        send(tag, parsed_content, cs: cs, raw: true, **attrs, &block)
+      end
+    end
+  end
+end

data/lib/joys/toys.rb

@@ -0,0 +1,328 @@
+# Define a cycle helper that keeps its state per-key
+# frozen_string_literal: true
+# lib/joys/toys.rb - Intelligent Core Extensions
+module Joys
+  module Toys
+    module CoreExtensions
+      module Numeric
+        
+        # 3127613.filesize(:kb) => "3.0 GB", 1536.filesize => "1.5 KB"
+        def filesize(unit = :bytes)
+          # Convert input to bytes first
+          bytes = case unit
+                  when :bytes, :b then self
+                  when :kb then self * 1024
+                  when :mb then self * 1024 * 1024  
+                  when :gb then self * 1024 * 1024 * 1024
+                  when :tb then self * 1024 * 1024 * 1024 * 1024
+                  else self
+                  end
+          
+          # Then convert bytes to human readable
+          return "#{bytes} B" if bytes < 1024
+          
+          units = [
+            [1024**4, 'TB'],
+            [1024**3, 'GB'], 
+            [1024**2, 'MB'],
+            [1024, 'KB']
+          ]
+          units.each do |threshold, suffix|
+            if bytes >= threshold
+              value = bytes.to_f / threshold
+              formatted = value % 1 == 0 ? value.to_i.to_s : "%.1f" % value
+              return "#{formatted} #{suffix}"
+            end
+          end
+          
+          "#{bytes} B"
+        end
+        # 21 => "21st", 102 => "102nd"
+        def ordinal
+          return self.to_s if self < 0
+          
+          suffix = case self.to_i % 100
+                   when 11, 12, 13 then 'th'
+                   else
+                     case self.to_i % 10
+                     when 1 then 'st'
+                     when 2 then 'nd' 
+                     when 3 then 'rd'
+                     else 'th'
+                     end
+                   end
+          "#{self}#{suffix}"
+        end
+        
+        # 1200 => "1.2K", 1000000 => "1M", 1500000000 => "1.5B"
+        def compact
+          return self.to_s if self.abs < 1000
+          
+          units = [
+            [1_000_000_000_000, 'T'],
+            [1_000_000_000, 'B'], 
+            [1_000_000, 'M'],
+            [1_000, 'K']
+          ]
+          
+          units.each do |threshold, suffix|
+            if self.abs >= threshold
+              value = self.to_f / threshold
+              formatted = value % 1 == 0 ? value.to_i.to_s : "%.1f" % value
+              return "#{formatted}#{suffix}"
+            end
+          end
+          
+          self.to_s
+        end
+        
+        # 42 => "forty-two", 123 => "one hundred twenty-three"
+        def spell
+          return 'zero' if self == 0
+          return self.to_s if self < 0 || self >= 1_000_000
+          
+          ones = %w[zero one two three four five six seven eight nine ten eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteen]
+          tens = %w[zero ten twenty thirty forty fifty sixty seventy eighty ninety]
+          
+          num = self.to_i
+          result = []
+          
+          # Thousands
+          if num >= 1000
+            result << ones[num / 1000] + ' thousand'
+            num %= 1000
+          end
+          
+          # Hundreds
+          if num >= 100
+            result << ones[num / 100] + ' hundred'
+            num %= 100
+          end
+          
+          # Tens and ones
+          if num >= 20
+            ten_part = tens[num / 10]
+            one_part = num % 10 > 0 ? ones[num % 10] : nil
+            result << [ten_part, one_part].compact.join('-')
+          elsif num > 0
+            result << ones[num]
+          end
+          
+          result.join(' ')
+        end
+        
+        # 4 => "IV", 1994 => "MCMXCIV"
+        def roman
+          return '' if self <= 0 || self >= 4000
+          
+          values = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]
+          numerals = %w[M CM D CD C XC L XL X IX V IV I]
+          
+          result = ''
+          num = self.to_i
+          
+          values.each_with_index do |value, index|
+            count = num / value
+            result += numerals[index] * count
+            num -= value * count
+          end
+          
+          result
+        end
+
+        # 10.20.cash('€') => "10.20€", 10.20.cash('$') => "$10.20"  
+        def cash(currency = '$')
+          formatted = "%.2f" % self
+          
+          # Currency positioning logic
+          case currency.to_s
+          when '$', '¥', '₩', '₹', '₪' # Prefix currencies
+            "#{currency}#{formatted}"
+          when '€', '£', '₽', 'kr', 'zł' # Suffix currencies  
+            "#{formatted}#{currency}"
+          else # Unknown - default to prefix
+            "#{currency}#{formatted}"
+          end
+        end
+      end
+      
+      module String
+        # "hello world-foo" => "Hello World Foo" (smart about separators)
+        def title
+          self.split(/[\s\-_]+/).map(&:capitalize).join(' ')
+        end
+        
+        # "John Wesley Doe" => "JWD"
+        def initials  
+          self.split(/\s+/).map { |word| word[0]&.upcase }.compact.join
+        end
+        
+        # "hello_world" => "HelloWorld"
+        def camel
+          self.split(/[\s\-_]+/).map.with_index { |word, i| 
+            i == 0 ? word.downcase : word.capitalize 
+          }.join
+        end
+        
+        # "HelloWorld" => "hello_world"
+        def snake
+          self.gsub(/([A-Z])/, '_\1').downcase.sub(/^_/, '')
+        end
+        
+        # "Hello World!" => "hello-world"  
+        def slug
+          self.downcase
+              .gsub(/[^\w\s\-]/, '') # Remove special chars except spaces/hyphens
+              .strip
+              .gsub(/[\s\-_]+/, '-') # Convert spaces/underscores to hyphens
+              .gsub(/\-+/, '-')      # Collapse multiple hyphens
+              .gsub(/^\-|\-$/, '')   # Remove leading/trailing hyphens
+        end
+        
+        # "1234567890" => "(123) 456-7890"
+        def phone
+          digits = self.gsub(/\D/, '')
+          return self if digits.length != 10
+          
+          "(#{digits[0..2]}) #{digits[3..5]}-#{digits[6..9]}"
+        end
+        
+        # "Long text here".snip(10) => "Long te..." (smart ellipsis)
+        def snip(length, ellipsis = '...')
+          return self if self.length <= length
+          return self if length < ellipsis.length + 1 # Don't make it longer!
+          
+          # Smart truncation - try to break on word boundary near the limit
+          if length > 10
+            word_break = self[0..length-ellipsis.length].rindex(/\s/)
+            if word_break && word_break > length * 0.7 # Only if reasonably close
+              return self[0..word_break-1] + ellipsis
+            end
+          end
+          
+          self[0..length-ellipsis.length-1] + ellipsis
+        end
+        
+        # "hello world".hilite("world") => "hello <mark>world</mark>" 
+        def hilite(term)
+          return self if term.nil? || term.empty?
+          self.gsub(/(#{Regexp.escape(term)})/i, '<mark>\1</mark>')
+        end
+        
+        # "Secret info here".redact(/\w{6,}/) => "****** info ****"
+        def redact(pattern = /\w{4,}/)
+          self.gsub(pattern) { |match| '*' * match.length }
+        end
+      end
+      
+      module Time  
+        # 2.hours.ago.ago => "2h ago" (smart recent time)
+        def ago(format = :short)
+          diff = ::Time.now - self
+          return 'just now' if diff < 60
+          
+          case format
+          when :short
+            case diff
+            when 0...3600        then "#{(diff/60).to_i}m ago"
+            when 3600...86400    then "#{(diff/3600).to_i}h ago" 
+            when 86400...2592000 then "#{(diff/86400).to_i}d ago"
+            else strftime('%b %d')
+            end
+          when :long
+            case diff  
+            when 0...3600        then "#{(diff/60).to_i} minutes ago"
+            when 3600...86400    then "#{(diff/3600).to_i} hours ago"
+            when 86400...2592000 then "#{(diff/86400).to_i} days ago" 
+            else strftime('%B %d, %Y')
+            end
+          end
+        end
+      end
+      
+      module Date
+        # Date.today.weekday => "Mon", Date.today.weekday(:long) => "Monday"
+        def weekday(format = :short)
+          format == :long ? strftime('%A') : strftime('%a')
+        end
+        
+        # Date.new(2024,6,15).season => "Summer"
+        def season
+          month = self.month
+          case month
+          when 12, 1, 2  then 'Winter'
+          when 3, 4, 5   then 'Spring'  
+          when 6, 7, 8   then 'Summer'
+          when 9, 10, 11 then 'Fall'
+          end
+        end
+        
+        # Date.today.smart => "Today", Date.yesterday.smart => "Yesterday"
+        def smart
+          today = Date.today
+          return 'Today' if self == today
+          return 'Yesterday' if self == today - 1
+          return 'Tomorrow' if self == today + 1
+          
+          # This year - show month/day
+          if self.year == today.year
+            strftime('%b %d')
+          else
+            strftime('%b %d, %Y')  
+          end
+        end
+        
+        # Date.today.schedule("+2d") => 2 days from now, Date.today.schedule("-1w") => 1 week ago
+        def schedule(offset_string)
+          match = offset_string.match(/([+-]?)(\d+)([dwmyh])/)
+          return self unless match
+          
+          sign, amount, unit = match.captures
+          multiplier = sign == '-' ? -1 : 1
+          amount = amount.to_i * multiplier
+          
+          case unit
+          when 'd' # days
+            self + amount
+          when 'w' # weeks  
+            self + (amount * 7)
+          when 'm' # months
+            self >> amount # Use Ruby's month arithmetic
+          when 'y' # years
+            self >> (amount * 12)
+          when 'h' # hours (convert to datetime)
+            (self.to_time + (amount * 3600)).to_date
+          else
+            self
+          end
+        end
+      end
+      
+      module Integer
+        # 7265.duration => "2h 1m", 90.duration => "1m 30s"
+        def duration(format = :short)
+          seconds = self
+          return '0s' if seconds == 0
+          
+          hours = seconds / 3600
+          minutes = (seconds % 3600) / 60
+          secs = seconds % 60
+          
+          parts = []
+          parts << "#{hours}h" if hours > 0
+          parts << "#{minutes}m" if minutes > 0  
+          parts << "#{secs}s" if secs > 0 && hours == 0 # Only show seconds if under 1 hour
+          
+          parts.join(' ')
+        end
+      end
+    end
+  end
+end
+
+# Apply the extensions
+Numeric.include Joys::Toys::CoreExtensions::Numeric  
+String.include Joys::Toys::CoreExtensions::String
+Time.include Joys::Toys::CoreExtensions::Time
+Date.include Joys::Toys::CoreExtensions::Date  
+Integer.include Joys::Toys::CoreExtensions::Integer

data/lib/joys/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Joys
-  VERSION = "0.1.1"
+  VERSION = "0.1.3"
 end

data/lib/joys.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 require_relative "joys/version"
-
-module Joys
-  class Error < StandardError; end
-  # Your code goes here...
-end
+require_relative "joys/core"
+require_relative "joys/helpers"
+require_relative "joys/styles"
+require_relative "joys/tags"
+require_relative "joys/config"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: joys
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Steven Garcia
@@ -18,15 +18,26 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".DS_Store"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - LICENSE
 - LICENSE.txt
 - README.md
 - Rakefile
+- joys-0.1.0.gem
+- joys-0.1.1.gem
+- joys-0.1.2.gem
 - lib/.DS_Store
 - lib/joys.rb
+- lib/joys/cli.rb
+- lib/joys/config.rb
+- lib/joys/core.rb
+- lib/joys/data.rb
+- lib/joys/helpers.rb
+- lib/joys/ssg.rb
+- lib/joys/styles.rb
+- lib/joys/tags.rb
+- lib/joys/toys.rb
 - lib/joys/version.rb
 - sig/joys.rbs
 homepage: https://github.com/activestylus/joys.git