tusktsk 2.0.1

data/lib/tusk_lang/tsk_parser_enhanced.rb

@@ -0,0 +1,563 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'time'
+
+module TuskLang
+  # TuskLang Enhanced Parser for Ruby
+  # "We don't bow to any king" - Support ALL syntax styles
+  #
+  # Features:
+  # - Multiple grouping: [], {}, <>
+  # - $global vs section-local variables
+  # - Cross-file communication
+  # - Database queries (placeholder adapters)
+  # - All @ operators
+  # - Maximum flexibility
+  #
+  # DEFAULT CONFIG: peanut.tsk (the bridge of language grace)
+  class TSKParserEnhanced
+    attr_reader :data, :global_variables, :section_variables
+
+    def initialize
+      @data = {}
+      @global_variables = {}
+      @section_variables = {}
+      @cache = {}
+      @cross_file_cache = {}
+      @current_section = ''
+      @in_object = false
+      @object_key = ''
+      @peanut_loaded = false
+      
+      # Standard peanut.tsk locations
+      @peanut_locations = [
+        './peanut.tsk',
+        '../peanut.tsk',
+        '../../peanut.tsk',
+        '/etc/tusklang/peanut.tsk',
+        File.join(Dir.home, '.config/tusklang/peanut.tsk'),
+        ENV['TUSKLANG_CONFIG']
+      ].compact
+    end
+
+    # Load peanut.tsk if available
+    def load_peanut
+      return if @peanut_loaded
+      
+      @peanut_loaded = true # Mark first to prevent recursion
+      
+      @peanut_locations.each do |location|
+        next if location.empty?
+        
+        if File.exist?(location)
+          puts "# Loading universal config from: #{location}"
+          parse_file(location)
+          return
+        end
+      end
+    end
+
+    # Parse TuskLang value with all syntax support
+    def parse_value(value)
+      value = value.strip
+      
+      # Remove optional semicolon
+      value = value.chomp(';').strip if value.end_with?(';')
+      
+      # Basic types
+      case value
+      when 'true' then return true
+      when 'false' then return false
+      when 'null' then return nil
+      end
+      
+      # Numbers
+      return value.to_i if value.match?(/^-?\d+$/)
+      return value.to_f if value.match?(/^-?\d+\.\d+$/)
+      
+      # $variable references (global)
+      if value.match?(/^\$[a-zA-Z_][a-zA-Z0-9_]*$/)
+        var_name = value[1..-1]
+        return @global_variables[var_name] || ''
+      end
+      
+      # Section-local variable references
+      if !@current_section.empty? && value.match?(/^[a-zA-Z_][a-zA-Z0-9_]*$/)
+        section_key = "#{@current_section}.#{value}"
+        return @section_variables[section_key] if @section_variables.key?(section_key)
+      end
+      
+      # @date function
+      date_match = value.match(/^@date\(['"](.*)['"]?\)$/)
+      if date_match
+        format_str = date_match[1]
+        return execute_date(format_str)
+      end
+      
+      # @env function with default
+      env_match = value.match(/^@env\(['"]([^'"]*)['"]?(?:,\s*(.+))?\)$/)
+      if env_match
+        env_var = env_match[1]
+        default_val = env_match[2]&.strip&.tr('"\'', '') || ''
+        return ENV[env_var] || default_val
+      end
+      
+      # Ranges: 8000-9000
+      range_match = value.match(/^(\d+)-(\d+)$/)
+      if range_match
+        return {
+          'min' => range_match[1].to_i,
+          'max' => range_match[2].to_i,
+          'type' => 'range'
+        }
+      end
+      
+      # Arrays
+      if value.start_with?('[') && value.end_with?(']')
+        return parse_array(value)
+      end
+      
+      # Objects
+      if value.start_with?('{') && value.end_with?('}')
+        return parse_object(value)
+      end
+      
+      # Cross-file references: @file.tsk.get('key')
+      cross_get_match = value.match(/^@([a-zA-Z0-9_-]+)\.tsk\.get\(['"](.*)['"]?\)$/)
+      if cross_get_match
+        file_name = cross_get_match[1]
+        key = cross_get_match[2]
+        return cross_file_get(file_name, key)
+      end
+      
+      # Cross-file set: @file.tsk.set('key', value)
+      cross_set_match = value.match(/^@([a-zA-Z0-9_-]+)\.tsk\.set\(['"]([^'"]*)['"]\?,\s*(.+)\)$/)
+      if cross_set_match
+        file_name = cross_set_match[1]
+        key = cross_set_match[2]
+        val = cross_set_match[3]
+        return cross_file_set(file_name, key, val)
+      end
+      
+      # @query function
+      query_match = value.match(/^@query\(['"](.*)['"]?(.*)\)$/)
+      if query_match
+        query = query_match[1]
+        return execute_query(query)
+      end
+      
+      # @ operators
+      operator_match = value.match(/^@([a-zA-Z_][a-zA-Z0-9_]*)\((.+)\)$/)
+      if operator_match
+        operator_name = operator_match[1]
+        parameters = operator_match[2]
+        return execute_operator(operator_name, parameters)
+      end
+      
+      # String concatenation
+      if value.include?(' + ')
+        parts = value.split(' + ')
+        result = ''
+        parts.each do |part|
+          part = part.strip.tr('"\'', '')
+          if !part.start_with?('"')
+            parsed_part = parse_value(part)
+            result += parsed_part.to_s
+          else
+            result += part[1..-2] if part.length > 1
+          end
+        end
+        return result
+      end
+      
+      # Conditional/ternary: condition ? true_val : false_val
+      ternary_match = value.match(/(.+?)\s*\?\s*(.+?)\s*:\s*(.+)/)
+      if ternary_match
+        condition = ternary_match[1].strip
+        true_val = ternary_match[2].strip
+        false_val = ternary_match[3].strip
+        
+        if evaluate_condition(condition)
+          return parse_value(true_val)
+        else
+          return parse_value(false_val)
+        end
+      end
+      
+      # Remove quotes from strings
+      if (value.start_with?('"') && value.end_with?('"')) ||
+         (value.start_with?("'") && value.end_with?("'"))
+        return value[1..-2]
+      end
+      
+      # Return as-is
+      value
+    end
+
+    # Parse array syntax
+    def parse_array(value)
+      content = value[1..-2].strip
+      return [] if content.empty?
+      
+      items = []
+      current = ''
+      depth = 0
+      in_string = false
+      quote_char = nil
+      
+      content.each_char do |ch|
+        if (ch == '"' || ch == "'") && !in_string
+          in_string = true
+          quote_char = ch
+        elsif ch == quote_char && in_string
+          in_string = false
+          quote_char = nil
+        end
+        
+        unless in_string
+          case ch
+          when '[', '{'
+            depth += 1
+          when ']', '}'
+            depth -= 1
+          when ','
+            if depth == 0
+              items << parse_value(current.strip)
+              current = ''
+              next
+            end
+          end
+        end
+        
+        current += ch
+      end
+      
+      items << parse_value(current.strip) unless current.strip.empty?
+      items
+    end
+
+    # Parse object syntax
+    def parse_object(value)
+      content = value[1..-2].strip
+      return {} if content.empty?
+      
+      pairs = []
+      current = ''
+      depth = 0
+      in_string = false
+      quote_char = nil
+      
+      content.each_char do |ch|
+        if (ch == '"' || ch == "'") && !in_string
+          in_string = true
+          quote_char = ch
+        elsif ch == quote_char && in_string
+          in_string = false
+          quote_char = nil
+        end
+        
+        unless in_string
+          case ch
+          when '[', '{'
+            depth += 1
+          when ']', '}'
+            depth -= 1
+          when ','
+            if depth == 0
+              pairs << current.strip
+              current = ''
+              next
+            end
+          end
+        end
+        
+        current += ch
+      end
+      
+      pairs << current.strip unless current.strip.empty?
+      
+      obj = {}
+      pairs.each do |pair|
+        if pair.include?(':')
+          colon_index = pair.index(':')
+          key = pair[0...colon_index].strip.tr('"\'', '')
+          val = pair[(colon_index + 1)..-1].strip
+          obj[key] = parse_value(val)
+        elsif pair.include?('=')
+          equals_index = pair.index('=')
+          key = pair[0...equals_index].strip.tr('"\'', '')
+          val = pair[(equals_index + 1)..-1].strip
+          obj[key] = parse_value(val)
+        end
+      end
+      
+      obj
+    end
+
+    # Evaluate conditions for ternary expressions
+    def evaluate_condition(condition)
+      condition = condition.strip
+      
+      # Simple equality check
+      if condition.include?('==')
+        left, right = condition.split('==', 2).map(&:strip)
+        return parse_value(left).to_s == parse_value(right).to_s
+      end
+      
+      # Not equal
+      if condition.include?('!=')
+        left, right = condition.split('!=', 2).map(&:strip)
+        return parse_value(left).to_s != parse_value(right).to_s
+      end
+      
+      # Greater than
+      if condition.include?('>')
+        left, right = condition.split('>', 2).map(&:strip)
+        left_val = parse_value(left)
+        right_val = parse_value(right)
+        
+        if left_val.is_a?(Numeric) && right_val.is_a?(Numeric)
+          return left_val > right_val
+        end
+        return left_val.to_s > right_val.to_s
+      end
+      
+      # Default: check if truthy
+      value = parse_value(condition)
+      case value
+      when true, false
+        value
+      when String
+        !value.empty? && value != 'false' && value != 'null' && value != '0'
+      when Numeric
+        value != 0
+      when nil
+        false
+      else
+        true
+      end
+    end
+
+    # Get value from another TSK file
+    def cross_file_get(file_name, key)
+      cache_key = "#{file_name}:#{key}"
+      
+      # Check cache
+      return @cross_file_cache[cache_key] if @cross_file_cache.key?(cache_key)
+      
+      # Find file
+      directories = ['.', './config', '..', '../config']
+      file_path = nil
+      
+      directories.each do |directory|
+        potential_path = File.join(directory, "#{file_name}.tsk")
+        if File.exist?(potential_path)
+          file_path = potential_path
+          break
+        end
+      end
+      
+      return '' unless file_path
+      
+      # Parse file and get value
+      temp_parser = TSKParserEnhanced.new
+      temp_parser.parse_file(file_path)
+      
+      value = temp_parser.get(key)
+      
+      # Cache result
+      @cross_file_cache[cache_key] = value
+      
+      value
+    end
+
+    # Set value in another TSK file (cache only for now)
+    def cross_file_set(file_name, key, value)
+      cache_key = "#{file_name}:#{key}"
+      parsed_value = parse_value(value)
+      @cross_file_cache[cache_key] = parsed_value
+      parsed_value
+    end
+
+    # Execute @date function
+    def execute_date(format_str)
+      now = Time.now
+      
+      # Convert PHP-style format to Ruby
+      case format_str
+      when 'Y'
+        now.strftime('%Y')
+      when 'Y-m-d'
+        now.strftime('%Y-%m-%d')
+      when 'Y-m-d H:i:s'
+        now.strftime('%Y-%m-%d %H:%M:%S')
+      when 'c'
+        now.iso8601
+      else
+        now.strftime('%Y-%m-%d %H:%M:%S')
+      end
+    end
+
+    # Execute database query (placeholder for now)
+    def execute_query(query)
+      load_peanut
+      
+      # Determine database type
+      db_type = get('database.default') || 'sqlite'
+      
+      # Placeholder implementation
+      "[Query: #{query} on #{db_type}]"
+    end
+
+    # Execute @ operators
+    def execute_operator(operator_name, parameters)
+      case operator_name
+      when 'cache'
+        # Simple cache implementation
+        parts = parameters.split(',', 2)
+        if parts.length == 2
+          ttl = parts[0].strip.tr('"\'', '')
+          value = parts[1].strip
+          return parse_value(value)
+        end
+        ''
+      when 'learn', 'optimize', 'metrics', 'feature'
+        # Placeholders for advanced features
+        "@#{operator_name}(#{parameters})"
+      else
+        "@#{operator_name}(#{parameters})"
+      end
+    end
+
+    # Parse a single line
+    def parse_line(line)
+      trimmed = line.strip
+      
+      # Skip empty lines and comments
+      return if trimmed.empty? || trimmed.start_with?('#')
+      
+      # Remove optional semicolon
+      trimmed = trimmed.chomp(';').strip if trimmed.end_with?(';')
+      
+      # Check for section declaration []
+      section_match = trimmed.match(/^\[([a-zA-Z_][a-zA-Z0-9_]*)\]$/)
+      if section_match
+        @current_section = section_match[1]
+        @in_object = false
+        return
+      end
+      
+      # Check for angle bracket object >
+      angle_open_match = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*>$/)
+      if angle_open_match
+        @in_object = true
+        @object_key = angle_open_match[1]
+        return
+      end
+      
+      # Check for closing angle bracket <
+      if trimmed == '<'
+        @in_object = false
+        @object_key = ''
+        return
+      end
+      
+      # Check for curly brace object {
+      brace_open_match = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*\{$/)
+      if brace_open_match
+        @in_object = true
+        @object_key = brace_open_match[1]
+        return
+      end
+      
+      # Check for closing curly brace }
+      if trimmed == '}'
+        @in_object = false
+        @object_key = ''
+        return
+      end
+      
+      # Parse key-value pairs (both : and = supported)
+      kv_match = trimmed.match(/^([\$]?[a-zA-Z_][a-zA-Z0-9_-]*)\s*[:=]\s*(.+)$/)
+      if kv_match
+        key = kv_match[1]
+        value = kv_match[2]
+        parsed_value = parse_value(value)
+        
+        # Determine storage location
+        storage_key = if @in_object && !@object_key.empty?
+                        if !@current_section.empty?
+                          "#{@current_section}.#{@object_key}.#{key}"
+                        else
+                          "#{@object_key}.#{key}"
+                        end
+                      elsif !@current_section.empty?
+                        "#{@current_section}.#{key}"
+                      else
+                        key
+                      end
+        
+        # Store the value
+        @data[storage_key] = parsed_value
+        
+        # Handle global variables
+        if key.start_with?('$')
+          var_name = key[1..-1]
+          @global_variables[var_name] = parsed_value
+        elsif !@current_section.empty? && !key.start_with?('$')
+          # Store section-local variable
+          section_key = "#{@current_section}.#{key}"
+          @section_variables[section_key] = parsed_value
+        end
+      end
+    end
+
+    # Parse TuskLang content
+    def parse(content)
+      lines = content.split("\n")
+      
+      lines.each { |line| parse_line(line) }
+      
+      @data
+    end
+
+    # Parse a TSK file
+    def parse_file(file_path)
+      content = File.read(file_path)
+      parse(content)
+    end
+
+    # Get a value by key
+    def get(key)
+      @data[key]
+    end
+
+    # Set a value
+    def set(key, value)
+      @data[key] = value
+    end
+
+    # Get all keys
+    def keys
+      @data.keys.sort
+    end
+
+    # Get all key-value pairs
+    def items
+      @data.dup
+    end
+
+    # Convert to JSON
+    def to_json
+      JSON.pretty_generate(@data)
+    end
+
+    # Load configuration from peanut.tsk
+    def self.load_from_peanut
+      parser = new
+      parser.load_peanut
+      parser
+    end
+  end
+end

data/lib/tusk_lang/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module TuskLang
+  VERSION = "2.0.1"
+end 

data/lib/tusk_lang.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# TuskLang Ruby SDK
+# The official TuskLang Configuration SDK for Ruby
+
+require_relative "tusk_lang/version"
+require_relative "tusk_lang/tsk"
+require_relative "tusk_lang/tsk_parser"
+require_relative "tusk_lang/shell_storage"
+
+module TuskLang
+  class Error < StandardError; end
+  # Your code goes here...
+end