deadfire 0.1.0

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "deadfire"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/bin/test

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+if [[ -z $1 ]]; then
+    bundle exec rake
+else
+    bundle exec rake TEST="$1"
+fi

data/changelog.md

@@ -0,0 +1,5 @@
+## Changelog
+
+### 0.1.0 (17 October 2022)
+
+Initial release

data/deadfire.gemspec

@@ -0,0 +1,26 @@
+require_relative 'lib/deadfire/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "deadfire"
+  spec.version       = Deadfire::VERSION
+  spec.authors       = ["Haroon Ahmed"]
+  spec.email         = ["haroon.ahmed25@gmail.com"]
+
+  spec.summary       = "Deadfire - lightweight css preprocessor"
+  spec.homepage      = "https://github.com/hahmed/deadfire"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.7")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/hahmed/deadfire"
+  spec.metadata["changelog_uri"] = "https://github.com/hahmed/deadfire/changelog.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+end

data/lib/deadfire/configuration.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Deadfire
+  class Configuration
+    attr_reader :directories, :root_path, :keep_comments
+
+    def initialize
+      @directories = []
+      @root_path = ""
+      @keep_comments = true
+    end
+
+    def root_path=(value)
+      unless Dir.exist?(value)
+        raise DirectoryNotFoundError.new("Root not found #{value}")
+      end
+      @root_path = value
+    end
+
+    def keep_comments=(value)
+      @keep_comments = value
+    end
+  end
+end

data/lib/deadfire/css_buffer.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+require "stringio"
+
+module Deadfire
+  class CssBuffer < StringIO
+    def initialize(content)
+      super(content)
+    end
+  end
+end

data/lib/deadfire/errors.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Deadfire
+  class DirectoryNotFoundError < StandardError; end
+  class Error < StandardError; end
+
+  class DuplicateImportException < StandardError
+    def initialize(filename = "", lineno = "")
+      msg = if filename
+        "Duplicate import found: `#{filename}` line: #{lineno}"
+      else
+        "Duplicate import."
+      end
+
+      super(msg)
+    end
+  end
+
+  class ImportException < StandardError
+    def initialize(filename = "", lineno = "")
+      msg = if filename
+        "Error importing file: `#{filename}` line: #{lineno}"
+      else
+        "Error importing file."
+      end
+
+      super(msg)
+    end
+  end
+
+  class EarlyApplyException < StandardError
+    def initialize(input = "", lineno = "")
+      msg = if input
+        "Error with input: `#{input}` line: #{lineno}"
+      else
+        "Apply called too early in css. There are no mixins defined."
+      end
+
+      super(msg)
+    end
+  end
+end

data/lib/deadfire/parser.rb

@@ -0,0 +1,380 @@
+# frozen_string_literal: true
+module Deadfire
+  class Parser
+    singleton_class.attr_accessor :cached_mixins
+    self.cached_mixins = Hash.new { |h, k| h[k] = {} }
+
+    singleton_class.attr_accessor :import_path_cache
+    self.import_path_cache = []
+
+    ROOT_SELECTOR = ":root {"
+    OPENING_SELECTOR_PATTERN = /\s*\{/
+    CLOSING_SELECTOR_PATTERN  = /\s*\}/
+    NEST_SELECTOR = "&"
+    START_BLOCK_CHAR = "{"
+    END_BLOCK_CHAR = "}"
+    OPENING_SELECTOR_PATTERN_OTHER  = /\..*\{/
+    IMPORT_SELECTOR = "@import"
+    CSS_FILE_EXTENSION = ".css"
+    APPLY_SELECTOR = "@apply"
+    NEWLINE = "\n"
+
+    def self.parse(content, options = {})
+      new(content, options).parse
+    end
+
+    attr_reader :output
+
+    def initialize(content, options = {})
+      @content  = content
+      @filename = options[:filename]
+      @output   = []
+      @imports  = []
+    end
+
+    def buffer
+      @buffer ||= CssBuffer.new(@content)
+    end
+
+    class Line
+      attr_accessor :content, :line_number
+
+      def initialize(content, line_number)
+        @content = content
+        @line_number = line_number
+      end
+
+      def to_s
+        content
+      end
+    end
+
+    class Root < Line
+      def initialize(content, lineno, buffer)
+        super(content, lineno)
+        @end_tag = false
+        @output_current_line = true
+        @output = []
+        @buffer = buffer
+      end
+
+      def parse
+        line = @content
+        if line.include? ROOT_SELECTOR
+          @output << Line.new(line, @line_number)
+        end
+
+        while !@end_tag && line = @buffer.gets
+          if line =~ OPENING_SELECTOR_PATTERN
+            @output_current_line = false
+            name = extract_mixin_name(line)
+            properties = extract_properties_from_mixin(@buffer, line)
+            Parser.cached_mixins[name] = properties
+          elsif line =~ CLOSING_SELECTOR_PATTERN
+            @end_tag = true
+          end
+  
+          @output << Line.new(line, @buffer.lineno) if @output_current_line
+          @output_current_line = true
+        end
+
+        to_s
+      end
+
+      def to_s
+        return "" if @output.size <= 1
+
+        @output.map(&:to_s)
+      end
+
+      private
+
+      def extract_mixin_name(line)
+        line.tr("{", "").tr(".", "").tr(":", "").strip
+      end
+  
+      def extract_properties_from_mixin(buffer, line)
+        properties = {}
+        line = buffer.gets # skip opening {
+        while line !~ CLOSING_SELECTOR_PATTERN && !buffer.eof?
+          name, value = extract_name_and_values(line)
+          properties[name] = value
+          line = buffer.gets
+        end
+        properties
+      end
+  
+      def extract_name_and_values(line)
+        name, value = line.split(":")
+        value = value.gsub(";", "")
+        [name, value].map(&:strip)
+      end
+    end
+
+    class Import < Line
+      attr_accessor :import_path
+
+      def initialize(content, lineno)
+        super
+        @import_path = self.class.resolve_import_path(content, lineno)
+      end
+
+      def parse
+        Parser.new(File.read(import_path), filename: import_path).parse
+      end
+
+      class << self
+        def resolve_import_path(line, lineno = 0)
+          path = normalize_import_path(line)
+          unless path.end_with?(Parser::CSS_FILE_EXTENSION)
+            path += Parser::CSS_FILE_EXTENSION
+          end
+          import_path = File.join(Deadfire.configuration.root_path, path)
+
+          unless File.exist?(import_path)
+            raise Deadfire::ImportException.new(import_path, lineno)
+          end
+
+          import_path
+        end
+        
+        def normalize_import_path(line)
+          path = line.split.last
+          path.gsub!("\"", "")
+          path.gsub!("\'", "")
+          path.gsub!(";", "")
+          path
+        end
+      end
+    end
+
+    class Apply < Line
+      def initialize(...)
+        super
+        @current_line = @content.dup
+        @space  = " "
+        @space_counter = 0
+        @import_start_tag = "@"
+        @output = []
+      end
+
+      def parse
+        raise Deadfire::EarlyApplyException.new(@content, @lineno) if Parser.cached_mixins.empty?
+  
+        @current_line.each_char do |char|
+          break if char == @import_start_tag
+          @space_counter += 1
+        end
+  
+        @current_line.split(" ").each do |css|
+          next if css.include?(APPLY_SELECTOR)
+          css.gsub!(";", "")
+          
+          fetch_cached_mixin(css).each_pair do |key, value|
+            @output << "#{@space * @space_counter}#{key}: #{value};"
+          end
+        end
+        @output
+      end
+
+      private
+
+      # find css class key/val from hash, otherwise throw because the mixin is not defined
+      def fetch_cached_mixin(key)
+        raise Deadfire::EarlyApplyException.new(key, @lineno) unless Parser.cached_mixins.include?(key)
+
+        Parser.cached_mixins[key]
+      end
+    end
+
+    class Nesting < Line
+      attr_accessor :block_names
+
+      def initialize(content, lineno, buffer, output)
+        super(content, lineno)
+        @buffer = buffer
+        @output = output
+        @block_names = []
+        @nested_level = 0
+      end
+
+      def parse
+        line = content.dup.strip
+        @block_names << find_block_name(@output, @lineno)
+        tmp = []
+        
+        add_end_block_when_no_end_block_on_prev_line(arr: tmp)
+        while @nested_level > 0 || !@buffer.eof?
+          spaces = calculate_spaces_to_add(line)
+          if line.start_with?(NEST_SELECTOR)
+            add_end_block_when_no_end_block_on_prev_line(arr: tmp) if @nested_level > 0
+            add_selector_to_block_name(line)
+            @nested_level += 1
+            tmp << rewrite_line(spaces, line, @block_names[0...-1].join(" "))
+            remove_last_block_name_entry if line.end_with?(END_BLOCK_CHAR)
+          else
+            remove_last_block_name_entry if line.end_with?(END_BLOCK_CHAR)
+            tmp << "#{spaces}#{line.lstrip}"
+          end
+
+          line = @buffer.gets
+
+          if line.nil? || @buffer.eof? || line.empty?
+            break
+          else
+            line.strip!
+          end
+        end
+
+        tmp.pop if tmp[-1] == END_BLOCK_CHAR
+        tmp.join("\n")
+      end
+
+      private
+
+      def remove_last_block_name_entry
+        @nested_level -= 1
+        @block_names.pop
+      end
+
+      def add_selector_to_block_name(line)
+        line = extract_selector(line)
+        line = line_without_nested_block(line)
+        @block_names << line unless @block_names.include?(line)
+      end
+
+      def add_end_block_when_no_end_block_on_prev_line(arr: @output)
+        unless arr[-1]&.strip&.end_with?("}")
+          arr << "}"
+        end
+      end
+
+      def calculate_spaces_to_add(line)
+        unless line =~ OPENING_SELECTOR_PATTERN || line =~ CLOSING_SELECTOR_PATTERN
+          "  "
+        else
+          ""
+        end
+      end
+  
+      def extract_selector(line)
+        line.split(START_BLOCK_CHAR).first.strip
+      end
+
+      def line_without_nested_block(line)
+        line.split(NEST_SELECTOR).last.strip
+      end
+  
+      def rewrite_line(spaces, line, selector)
+        case number_of_selectors_in(line)
+        when 0
+          line
+        when 1
+          "#{spaces}#{line.lstrip.gsub("&", selector)}"
+        else
+          line.strip.each_char.map do |s|
+            if s == NEST_SELECTOR
+              selector
+            else
+              s
+            end
+          end.join
+        end
+      end
+  
+      def number_of_selectors_in(line)
+        line.split.count do |s|
+          # break if s == "{" # early exit, no need to read every char
+          s.start_with?(NEST_SELECTOR)
+        end
+      end
+  
+      def find_block_name(output, lineno = nil)
+        lineno = output.size unless lineno
+        if lineno < 0
+          raise "Cannot find block name"
+        end
+
+        line = output[lineno]
+  
+        if line.to_s =~ OPENING_SELECTOR_PATTERN
+          extract_selector(line)
+        else
+          find_block_name(output, lineno - 1)
+        end
+      end
+    end
+
+    def parse
+      while ! buffer.eof?
+        process_line(buffer.readline)
+      end
+
+      @output << NEWLINE
+
+      @output.join
+    end
+
+    private
+
+    # this method returns void, and modifies the output array directly
+    def process_line(line)
+      if line.strip.start_with?("/*")
+        handle_comment(line)
+      elsif line.strip.start_with?("@import")
+        handle_import(line)
+      elsif line.strip.start_with?(":root {")
+        handle_mixins(line)
+      elsif line.strip.start_with?("@apply") # or line.include?("@apply")
+        handle_apply(line)
+      elsif line.strip.start_with?("&")
+        handle_nestings(line)
+      else
+        @output << line
+      end
+    end
+
+    def keep_comments?
+      Deadfire.configuration.keep_comments
+    end
+
+    def handle_comment(line)
+      @output << Line.new(line, buffer.lineno) if keep_comments?
+
+      while ! line.include?("*/") && ! buffer.eof?
+        line = buffer.gets
+        @output << Line.new(line, buffer.lineno) if keep_comments?
+      end
+    end
+
+    def handle_import(line)
+      import = Import.new(line, buffer.lineno)
+
+      if self.class.import_path_cache.include?(import.import_path)
+        raise DuplicateImportException.new(import.import_path, buffer.lineno)
+      end
+
+      self.class.import_path_cache << import.import_path
+
+      # TODO: 
+      # - decide on how many levels of imports we want to allow
+      # - make async??
+      @output << import.parse
+    end
+
+    def handle_apply(line)
+      @apply = Apply.new(line, buffer.lineno)
+      @output << @apply.parse.join(NEWLINE)
+    end
+
+    def handle_mixins(line)
+      @root = Root.new(line, buffer.lineno, buffer)
+      @output << @root.parse
+    end
+
+    def handle_nestings(line)      
+      nesting = Nesting.new(line, buffer.lineno, buffer, @output)
+      @output << nesting.parse
+    end
+  end
+end

data/lib/deadfire/transformers/transformer.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Deadfire::Transformers
+  class Transformer
+    def name
+      self.class.name
+    end
+  
+    def matches?(line)
+      false
+    end
+  
+    def transform(line, buffer, output); end
+  
+    def reset; end
+  end
+end

data/lib/deadfire/version.rb

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

data/lib/deadfire.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "deadfire/css_buffer"
+require_relative "deadfire/configuration"
+require_relative "deadfire/errors"
+require_relative "deadfire/parser"
+require_relative "deadfire/transformers/transformer"
+require_relative "deadfire/version"
+
+module Deadfire
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def reset
+      @configuration = Configuration.new
+    end
+
+    def configure
+      yield(@configuration)
+    end
+
+    def parse(content, options = {})
+      Parser.parse(content, options)
+    end
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: deadfire
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Haroon Ahmed
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-10-17 00:00:00.000000000 Z
+dependencies: []
+description:
+email:
+- haroon.ahmed25@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- benchmarks/basic_benchmark.rb
+- benchmarks/input.scss
+- benchmarks/output.css
+- benchmarks/output.css.map
+- benchmarks/profilng.rb
+- benchmarks/tailwind.css
+- bin/console
+- bin/setup
+- bin/test
+- changelog.md
+- deadfire.gemspec
+- lib/deadfire.rb
+- lib/deadfire/configuration.rb
+- lib/deadfire/css_buffer.rb
+- lib/deadfire/errors.rb
+- lib/deadfire/parser.rb
+- lib/deadfire/transformers/transformer.rb
+- lib/deadfire/version.rb
+homepage: https://github.com/hahmed/deadfire
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/hahmed/deadfire
+  source_code_uri: https://github.com/hahmed/deadfire
+  changelog_uri: https://github.com/hahmed/deadfire/changelog.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: Deadfire - lightweight css preprocessor
+test_files: []