deadfire 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 681339c949e040e68156a6f391c2a0cb87a50fa84e7cff27e3d8dfe7e746b61a
-  data.tar.gz: 952f7522e6034261f9dd2b7912deea46fa92e43a068fa53b6ff2658db8e0cd36
+  metadata.gz: 82f838eee7d8e2ef83b302d7de509c428af8584567892296fd3011df42cb0990
+  data.tar.gz: 1a4b828032eda5dae38d3da5f820081402f7e66f919b2720ff8f9be65d6d8bf0
 SHA512:
-  metadata.gz: 7b72cecd27d13dfbcb84f1c06b19b4a0ef615df59d5cba0a4ffa544e423660dc24f8b445e9b92ef06f58fc71ef12140867e5c0fd4e45d9cbf28dd9fae15b64f6
-  data.tar.gz: 4c81de35669b3e560d8ee5103cd94a2ba45f703b27c64b1c5a26dc46dfefd35ac1f0825c26667b7d8c3e76ee27df0764dad571ddc0c4d652e88228cd494921d1
+  metadata.gz: a724bdb7b939e5b4404ee5cee4266ad6c278ac5d4e7fc74f560884f4b30fc123c3492a52abd5028adbc9f579dd690beb26d0de2460e8cb3b8e482d44ce77e733
+  data.tar.gz: e353841bfb20e25ff0ff1556d555443546783a744cf96b2a2149862cf8dbebb31bb9c48f50d68f20355ea036c36e22ca4ac9f059413df500974f4888849673bd

data/.github/workflows/ci.yml

@@ -6,7 +6,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: [head, 3.1, 3.0, 2.7]
+        ruby: [head, 3.3, 3.2, 3.1, 3.0, 2.7]
     steps:
     - uses: actions/checkout@v3
     - name: Set up Ruby
@@ -15,4 +15,4 @@ jobs:
         ruby-version: ${{ matrix.ruby }}
         bundler-cache: true
     - name: Run tests
-      run: bundle exec rake
+      run: bundle exec rake

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    deadfire (0.2.0)
+    deadfire (0.4.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -2,7 +2,7 @@
 
 A lightweight CSS preprocessor.
 
-Use plain ol' CSS with a little bit of @import, @apply and nestings.
+Use plain ol' CSS with a little bit of @import and @apply.
 
 CSS is a staple technology when building web applications. With the introduction of LESS, SASS, SCSS it made CSS easier to maintain. However, most of these tools are no longer supported, maintained or have far too many features (wait... that's a bad thing?).
 
@@ -14,7 +14,6 @@ Deadfire can be used with or without a CSS framework.
 
 - [x] @import
 - [x] [@apply](https://tabatkins.github.io/specs/css-apply-rule/)
-- [x] [nesting](https://drafts.csswg.org/css-nesting-1)
 
 ### @import
 
@@ -51,59 +50,65 @@ Output;
 
 ### @apply
 
-@apply inlines your classes into your custom css.
+The `@apply` directive inlines your classes into your custom CSS, simplifying the process of applying existing styles to a new class.
 
 The CSS apply rule was [proposed to be included into CSS](https://tabatkins.github.io/specs/css-apply-rule/) however it was abandoned. Mixins simplify applying existing css to a new class.
 
-All mixins must be declared on the `:root` element or preloaded via the `Deadfire.mixins` method. Using a mixin before it's declared will raise an `EarlyApplyException`. Ideally the `:root` element should appear near the top of the document.
-
-Let's see an example of how to declare mixins and use the @apply directive.
+Let's take a look at an example of how to use the @apply directive. Note that all utility classes are automatically cached.
 
 ```CSS
-:root {
-  --font-bold: {
-    font-weight: bold;
-  }
+.font-bold: {
+  font-weight: bold;
+}
 
-  --btn: {
-    padding-bottom: 10px;
-    text-align: center;
-  }
+.btn: {
+  padding-bottom: 10px;
+  text-align: center;
 }
 ```
 
-How can we use mixins? Using @apply...
+Re-use the styles using @apply:
 
 ```CSS
 .btn-blue {
-  @apply --btn --font-bold;
+  @apply .btn .font-bold;
 }
 
 .homepage-hero {
-  @apply --font-bold;
+  @apply .font-bold;
 }
 ```
 
-### nesting
+### Nesting
 
-Nesting adds the ability to nest one style rule inside another.
+The CSS nesting feature, as described in the CSS Nesting specification (https://drafts.csswg.org/css-nesting/), allows for more intuitive and concise styling by enabling the nesting of CSS rules within one another. This feature simplifies the structure of stylesheets and improves readability.
 
-NOTE: This feature is still a work in progress.
+Now that nesting has been upstreamed to CSS, meaning it is now a part of the official CSS specification. As a result, Deafire will leverage the native CSS nesting feature instead of implementing this feature (which was the original goal of this project).
 
-```CSS
-/* & can be used on its own */
-.btn {
-  color: blue;
-  & > .homepage { color: red; }
+Example:
+
+```css
+.foo {
+  color: green;
+}
+.foo .bar {
+  font-size: 1.4rem;
+}
+
+/* can be simplified to  */
+.foo {
+  color: green;
+  .bar {
+    font-size: 1.4rem;
+  }
 }
 ```
 
-This is expanded to:
+### Fault tolerant
 
-```CSS
-.btn { color: blue; }
-.btn > .homepage { color: red; }
-```
+When Deadfire encounters an error, such as a missing mixin or other issues, it does not immediately raise an error that would halt the execution. Instead, it continues processing the CSS code and collects the encountered errors. These errors are then reported through the ErrorReporter class, allowing you to handle or display them as needed.
+
+By adopting this fault-tolerant approach, Deadfire aims to provide more flexibility and resilience when dealing with CSS code that may contain errors or inconsistencies. It allows you to gather information about the encountered issues and take appropriate actions based on the reported errors.
 
 ## Installation
 
@@ -123,7 +128,25 @@ Or install it yourself as:
 
 ## Deadfire + Ruby on Rails
 
-After adding Deadfire gem to your rails application, open the file `config/initializers/assets.rb` to setup your Sprocket and the asset pipeline to use the new preprocessor.
+After adding Deadfire gem to your rails application, open the file `config/initializers/assets.rb` or create a new initializer `config/initializers/deadfire.rb`.
+
+### Propshaft
+
+To setup Propshaft to use Deadfire as a preprocessor:
+
+```ruby
+# config/initializers/assets.rb
+class DeadfireCompiler < Propshaft::Compiler
+  def compile(logical_path, input)
+    Deadfire.parse(input, root_path: Rails.root.join("app", "assets", "stylesheets"))
+  end
+end
+
+Rails.application.config.assets.compilers << ["text/css", DeadfireCompiler]
+```
+### Sprockets
+
+To setup Sprocket to use Deadfire as a preprocessor:
 
 ```ruby
 # config/initializers/assets.rb
@@ -156,4 +179,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the Deadfire project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/hahmed/deadfire/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the Deadfire project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/hahmed/deadfire/blob/master/CODE_OF_CONDUCT.md).

data/benchmarks/basic_benchmark.rb

@@ -8,12 +8,13 @@ gemfile(true) do
   gem "sassc"
   gem "deadfire", github: "hahmed/deadfire", branch: "main"
   gem "syntax_tree-css"
+  gem "sass-embedded"
 
   gem "benchmark-ips"
 end
 
 css = <<~CSS
-
+/* My very first css file! */
 body {
   font-family: helvetica, arial, sans-serif;
   font-size: calc(1.3em + 0.5vw);
@@ -25,9 +26,12 @@ body {
 }
 
 h1 {
-  font-size: 40px; 
+  font-size: 40px;
 }
-
+/* Just
+a
+random
+comment */
 a {
   font-size: 1em;
   vertical-align: baseline;
@@ -41,9 +45,7 @@ a {
   text-decoration-width: 0.1rem
 }
 
-.button--block {
-  min-width:100% !important
-}
+.button--block { min-width:100% !important }
 
 code {
   font-family: Roboto Mono;
@@ -51,26 +53,59 @@ code {
   color: gray;
 }
 
+/* I like code                  blocks!!!!!======= */
+
 .banner {
   border: 1px solid #ccc;
 }
 CSS
 
-def dartsass
-  system "sass benchmarks/input.scss output.css", exception: true
-end
-
 Benchmark.ips do |x|
   x.config(:time => 5, :warmup => 2)
 
-  x.report("dartsass") { dartsass }
+  # x.report("dartsass") { dartsass }
   x.report("deadfire")    { Deadfire.parse(css) }
   x.report("sassc")       { SassC::Engine.new(css).render }
   x.report("sytanx_tree") { SyntaxTree::CSS.parse(css) }
+  x.report("dart sass")   { Sass.compile_string(css) }
   x.compare!
 end
 
-# FYI
+# May 2024: Re-added dart sass
+# Warming up --------------------------------------
+#             deadfire   172.000 i/100ms
+#                sassc    85.000 i/100ms
+#          sytanx_tree    79.000 i/100ms
+#            dart sass   520.000 i/100ms
+# Calculating -------------------------------------
+#             deadfire      1.680k (± 0.9%) i/s -      8.428k in   5.018094s
+#                sassc    816.292 (± 0.2%) i/s -      4.165k in   5.102378s
+#          sytanx_tree    750.421 (± 1.9%) i/s -      3.792k in   5.054908s
+#            dart sass      5.225k (± 4.7%) i/s -     26.520k in   5.090927s
+
+# Comparison:
+#            dart sass:     5224.7 i/s
+#             deadfire:     1679.7 i/s - 3.11x  slower
+#                sassc:      816.3 i/s - 6.40x  slower
+#          sytanx_tree:      750.4 i/s - 6.96x  slower
+
+# Nov 2023: (Note: removed dart sass because I don't have it installed, need to re-run again)
+# Warming up --------------------------------------
+#             deadfire   116.000  i/100ms
+#                sassc    69.000  i/100ms
+#          sytanx_tree    64.000  i/100ms
+# Calculating -------------------------------------
+#             deadfire      1.164k (± 1.2%) i/s -      5.916k in   5.084777s
+#                sassc    695.721  (± 1.3%) i/s -      3.519k in   5.059025s
+#          sytanx_tree    635.684  (± 3.3%) i/s -      3.200k in   5.040489s
+
+# Comparison:
+#             deadfire:     1163.6 i/s
+#                sassc:      695.7 i/s - 1.67x  slower
+#          sytanx_tree:      635.7 i/s - 1.83x  slower
+
+
+# Sep 2022:
 # Warming up --------------------------------------
 #             dartsass     1.000  i/100ms
 #             deadfire     1.088k i/100ms

data/benchmarks/tailwind_parser.rb

@@ -0,0 +1,23 @@
+require "bundler/inline"
+require 'benchmark'
+
+gemfile(true) do
+  source "https://rubygems.org"
+
+  git_source(:github) { |repo| "https://github.com/#{repo}.git" }
+
+  gem "deadfire", path: "./" #github: "hahmed/deadfire", branch: "main"
+end
+
+css = File.read("./benchmarks/tailwind.css")
+
+puts css.inspect
+puts "---"
+
+
+time = Benchmark.measure do
+  parser = Deadfire::ParserEngine.new(css)
+  parser.parse
+end
+
+puts time.real

data/bin/console

@@ -6,9 +6,22 @@ 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
+#  simple css test
+ css = <<-CSS
+  @page :first { margin: 1cm; }
+CSS
+
+  # @charset "UTF-8";
+  # @viewport { width: device-width; }
+  # @font-face {
+  #   font-family: "Open Sans";
+  # }
+
+puts css.inspect
+
+parser = Deadfire::ParserEngine.new(css)
+parser.print_ast
+puts parser.parse
 
 require "irb"
 IRB.start(__FILE__)

data/changelog.md

@@ -1,5 +1,42 @@
 ## Changelog
+### 0.5.0 (current)
+
+### 0.4.0 (18 May 2024)
+- Fix parsing comments that have 2 stars e.g. /**
+- Adds a logger and a default setting that suppresses the logs which can be configured to report errors.
+- Fixes issue with import's not parsing correctly when there is no ending semicolon.
+- Added ci for ruby 3.3
+- Add support for importing .scss files, making it easier to migrate from other libraries.
+```
+@import "nav"
+@import "sidebar.scss"
+.image { padding: 2px; }
+```
+Deadfire will look for the file nav.css, then nav.scss in the `config.root_path` in the case when a file extension is not included.
+
+- Simplify the configuration by having one option called compressed instead of keep_newlines and keep_comments.
+
+### 0.3.0 (15 November 2023)
+
+- Redo the parser by splitting up the tokenizer, parser, interpreter and generator phases which makes each step simpler. It's still faster than sassc but much slower than it was previously which is something I hope to address soon.
+- Key thing to note is that Deadfire now only handles @imports and mixins. Nesting is now a feature of CSS, which means Deadfire is much simpler as a result.
+- In the next version I will drop the old parser and it's tests.
+- Add support for Ruby 3.2
+- Updated docs and added an example on how to get Deadfire working with Propshaft.
+
+### 0.2.0 (25 October 2022)
+
+- Added build for ruby 3.0
+- StringIO is now hidden and only visible on the buffer class.
+- Fixed a bug with a css ruleset after a nested block was being ignored, example;
+```
+.title {
+  color: blue;
+  & .text { padding: 3px; }
+}
+.image { padding: 2px; }
+```
 
 ### 0.1.0 (17 October 2022)
 
-Initial release
+Initial release

data/lib/deadfire/ast_printer.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Deadfire
+  class AstPrinter # :nodoc:
+    def initialize
+      @indentation = 0
+    end
+
+    def print(node)
+      node.accept(self)
+    end
+
+    def visit_stylesheet_node(node)
+      puts "StylesheetNode"
+      node.statements.each do |statement|
+        # something
+      end
+    end
+
+    def visit_at_rule_node(node)
+      puts "AtRuleNode"
+      puts "  AtKeyword: #{node.at_keyword.lexeme}"
+      node.value.each do |value|
+        puts "  Value: #{value}"
+      end
+      if node.block
+        visit_block_node(node.block)
+      end
+    end
+
+    def visit_block_node(node)
+      puts "BlockNode"
+      node.declarations.each do |declaration|
+        case declaration
+        when FrontEnd::Token
+          puts "  Declaration: #{declaration.lexeme}"
+        when FrontEnd::AtRuleNode
+          visit_at_rule_node(declaration)
+        when FrontEnd::RulesetNode
+          visit_ruleset_node(declaration)
+        end
+      end
+    end
+
+    def visit_ruleset_node(node)
+      puts "RulesetNode"
+      puts "  Selector: #{node.selector}"
+      if node.block
+        visit_block_node(node.block)
+      end
+    end
+
+    def visit_comment_node(node)
+      puts "CommentNode"
+      puts "  Comment: #{node.comment.lexeme}"
+    end
+  end
+end

data/lib/deadfire/configuration.rb

@@ -1,24 +1,37 @@
 # frozen_string_literal: true
+require "logger"
 
 module Deadfire
   class Configuration
-    attr_reader :directories, :root_path, :keep_comments
+    attr_reader :directories, :root_path, :compressed, :logger, :supressed
 
     def initialize
       @directories = []
       @root_path = ""
-      @keep_comments = true
+      @compressed = false
+      @logger = Logger.new(STDOUT, level: :warn)
+      @supressed = true
     end
 
     def root_path=(value)
+      return if value.nil?
+
       unless Dir.exist?(value)
         raise DirectoryNotFoundError.new("Root not found #{value}")
       end
       @root_path = value
     end
 
-    def keep_comments=(value)
-      @keep_comments = value
+    def compressed=(value)
+      @compressed = value unless value.nil?
+    end
+
+    def logger=(value)
+      @logger = value
+    end
+
+    def supressed=(value)
+      @supressed = value
     end
   end
-end
+end

data/lib/deadfire/css_generator.rb

@@ -0,0 +1,65 @@
+# Frozen_string_literal: true
+require "stringio"
+
+module Deadfire
+  class CssGenerator # :nodoc:
+    def initialize(tree)
+      @tree = tree
+      @output = StringIO.new # TODO: write to file instead of string buffer in temp folder
+    end
+
+    def generate
+      @tree.accept(self)
+      @output.string
+    end
+
+    def visit_stylesheet_node(node)
+      node.statements.each { |child| child.accept(self) }.join("\n")
+    end
+
+    def visit_at_rule_node(node)
+      @output << node.at_keyword.lexeme
+      node.value.each do |value|
+        @output << value.lexeme
+      end
+
+      if node.block
+        visit_block_node(node.block)
+      end
+    end
+
+    def visit_ruleset_node(node)
+      @output << node.selector.selector
+      @output << " "
+
+      visit_block_node(node.block)
+    end
+
+    def visit_block_node(node)
+      node.declarations.each do |declaration|
+        case declaration
+        when ApplyNode
+          visit_apply_node(declaration)
+        when FrontEnd::BlockNode
+          visit_block_node(declaration)
+        when FrontEnd::AtRuleNode
+          visit_at_rule_node(declaration)
+        else
+          @output << declaration.lexeme
+        end
+      end
+    end
+
+    def visit_newline_node(node)
+      @output << node.text
+    end
+
+    def visit_apply_node(node)
+      @output << node.node.lexeme
+    end
+
+    def visit_comment_node(node)
+      @output << node.comment.lexeme unless Deadfire.configuration.compressed
+    end
+  end
+end

data/lib/deadfire/error_reporter.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Deadfire
+  class ErrorReporter # :nodoc:
+    attr_reader :errors
+
+    def initialize
+      @errors = []
+    end
+
+    def error(line, message)
+      error = Error.new(line, message)
+      Deadfire.configuration.logger.error(error.to_s) unless Deadfire.configuration.supressed
+      @errors << error
+    end
+
+    def errors?
+      @errors.any?
+    end
+
+    private
+
+    # create error struct with line and message
+    Error = Struct.new(:line, :message) do
+      def to_s
+        "Line #{line}: #{message}"
+      end
+    end
+  end
+end

data/lib/deadfire/errors.rb

@@ -2,7 +2,6 @@
 
 module Deadfire
   class DirectoryNotFoundError < StandardError; end
-  class Error < StandardError; end
 
   class DuplicateImportException < StandardError
     def initialize(filename = "", lineno = "")
@@ -27,16 +26,4 @@ module Deadfire
       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
+end

data/lib/deadfire/filename_helper.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Deadfire
+  class FilenameHelper
+    class << self
+      def resolve_import_path(line, lineno = 0)
+        path = normalize_path(line)
+        potential = potential_path(path)
+        ext = File.extname(path)
+
+        if ext && valid_file?(potential)
+          potential
+        else
+          possible_paths(path)
+        end
+      end
+
+      def normalize_path(line)
+        path = line.split.last
+        path.gsub!("\"", "")
+        path.gsub!("\'", "")
+        path.gsub!(";", "")
+        path
+      end
+
+      private
+
+      def valid_file_extension?(ext)
+        Deadfire::PERMISSIBLE_FILE_EXTENSIONS.include?(ext)
+      end
+
+      def valid_file?(path)
+        File.exist?(path)
+      end
+
+      def possible_paths(path)
+        Deadfire::PERMISSIBLE_FILE_EXTENSIONS.each do |ext|
+          option = File.join(Deadfire.configuration.root_path, path + ext)
+          return option if valid_file?(option)
+        end
+        nil
+      end
+
+      def potential_path(path)
+        File.join(Deadfire.configuration.root_path, path)
+      end
+    end
+  end
+end