deadfire 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b22d5497d512927d87bb9f0d4166b055281e8c684188b14b2c03b4052256fe0
-  data.tar.gz: c50413354b6e0504777d2111bf83a9f5e39a97f64f2fa14b292fd0277128f7be
+  metadata.gz: 570d2b607521baef50439b60e78f17aafcc9a6a53a258c2248967c6308964d27
+  data.tar.gz: ad3dc3a1ff0b925408cf64d73f41d659f7de3fbd2014d6d73ef55829d6246e68
 SHA512:
-  metadata.gz: 922f9283b553c8c6f92d4e8de65362f1d75b29e028b5a18ab3444e2727cbc09295c176ec5b0359d879dd11a5f942e626ab9256d1cb2f4c0f39c9c13200aca06f
-  data.tar.gz: 1bb7bbae48bd1e170c036ad176d3f0dd22b5546b87b2ec874f1fa9d0820b1ba23c7cdd2096caac8673be42d32be4e14063ae44d79d7fc66134d670b41ccc56e7
+  metadata.gz: d23aee619e6429b4e3dc964a833f46ba8cba5275aea228d3945a6a240308366e067563a1fea45310a13e69414280f3d831a0e7f298596172f1fd5da44ad67235
+  data.tar.gz: 911f68ad428ed00b46a9062cd96af4ff50fb2459aa2fff1be796fac7651b77e88f0e405c2da8b30d38a8d21a01ae5d0c0ace7daa245deac032e6450747f08c76

data/.github/workflows/ci.yml

@@ -6,13 +6,13 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: [head, 3, 2.7]
+        ruby: [head, 3.2, 3.1, 3.0, 2.7]
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
     - name: Set up Ruby
       uses: ruby/setup-ruby@v1
       with:
         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.1.0)
+    deadfire (0.3.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
 
@@ -55,20 +54,16 @@ Output;
 
 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.
 
 ```CSS
-:root {
-  --font-bold: {
-    font-weight: bold;
-  }
-
-  --btn: {
-    padding-bottom: 10px;
-    text-align: center;
-  }
+.font-bold: {
+  font-weight: bold;
+}
+
+.btn: {
+  padding-bottom: 10px;
+  text-align: center;
 }
 ```
 
@@ -76,34 +71,19 @@ How can we use mixins? Using @apply...
 
 ```CSS
 .btn-blue {
-  @apply --btn --font-bold;
+  @apply .btn .font-bold;
 }
 
 .homepage-hero {
-  @apply --font-bold;
+  @apply .font-bold;
 }
 ```
 
-### nesting
-
-Nesting adds the ability to nest one style rule inside another.
+### Fault tolerant
 
-NOTE: This feature is still a work in progress.
+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.
 
-```CSS
-/* & can be used on its own */
-.btn {
-  color: blue;
-  & > .homepage { color: red; }
-}
-```
-
-This is expanded to:
-
-```CSS
-.btn { color: blue; }
-.btn > .homepage { color: red; }
-```
+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 +103,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 +154,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

@@ -13,7 +13,7 @@ gemfile(true) do
 end
 
 css = <<~CSS
-
+/* My very first css file! */
 body {
   font-family: helvetica, arial, sans-serif;
   font-size: calc(1.3em + 0.5vw);
@@ -27,7 +27,10 @@ body {
 h1 {
   font-size: 40px; 
 }
-
+/* Just
+a
+random
+comment */
 a {
   font-size: 1em;
   vertical-align: baseline;
@@ -41,9 +44,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,6 +52,8 @@ code {
   color: gray;
 }
 
+/* I like code                  blocks!!!!!======= */
+
 .banner {
   border: 1px solid #ccc;
 }

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,25 @@
 ## Changelog
+### 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

@@ -2,12 +2,13 @@
 
 module Deadfire
   class Configuration
-    attr_reader :directories, :root_path, :keep_comments
+    attr_reader :directories, :root_path, :keep_comments, :keep_whitespace
 
     def initialize
       @directories = []
       @root_path = ""
       @keep_comments = true
+      @keep_whitespace = true
     end
 
     def root_path=(value)
@@ -20,5 +21,9 @@ module Deadfire
     def keep_comments=(value)
       @keep_comments = value
     end
+
+    def keep_whitespace=(value)
+      @keep_whitespace = value
+    end
   end
-end
+end

data/lib/deadfire/css_buffer.rb

@@ -2,9 +2,36 @@
 require "stringio"
 
 module Deadfire
-  class CssBuffer < StringIO
+  class CssBuffer
+    attr_reader :lineno, :buffer
+
     def initialize(content)
-      super(content)
+      @content = StringIO.new(content)
+      @buffer = []
+      @lineno = 0
+    end
+
+    def gets(skip_buffer: false)
+      output = content.gets
+      if output && !skip_buffer
+        buffer << output
+      end
+      @lineno += 1
+      output
+    end
+
+    def peek
+      output = content.gets
+      content.ungetc(output)
+      output
     end
+
+    def eof?
+      content.eof?
+    end
+
+    private
+
+    attr_reader :content
   end
-end
+end

data/lib/deadfire/css_generator.rb

@@ -0,0 +1,66 @@
+# 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
+      @output << " "
+      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 if Deadfire.configuration.keep_comments
+    end
+  end
+end

data/lib/deadfire/error_reporter.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Deadfire
+  class ErrorReporter # :nodoc:
+    attr_reader :errors
+
+    def initialize
+      @errors = []
+    end
+
+    def error(line, message)
+      @errors << Error.new(line, message)
+    end
+
+    def errors?
+      @errors.any?
+    end
+
+    private
+
+    # create error struct with line and message
+    Error = Struct.new(:line, :message)
+  end
+end

data/lib/deadfire/errors.rb

@@ -39,4 +39,32 @@ module Deadfire
       super(msg)
     end
   end
+
+  class SyntaxError < StandardError
+    def initialize(message = "", lineno = "", original_line = "")
+      msg = if message
+        "#{original_line}\nline: #{lineno}: #{message}"
+      else
+        "Syntax "
+      end
+
+      super(msg)
+    end
+  end
+
+  class ErrorsList
+    attr_reader :errors
+
+    def initialize
+      @errors = []
+    end
+
+    def add(message:, lineno:, original_line:)
+      @errors << SyntaxError.new(message, lineno, original_line)
+    end
+
+    def empty?
+      @errors.empty?
+    end
+  end
 end

data/lib/deadfire/filename_helper.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Deadfire
+  class FilenameHelper
+    class << self
+      def resolve_import_path(line, lineno = 0)
+        path = normalize_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_path(line)
+        path = line.split.last
+        path.gsub!("\"", "")
+        path.gsub!("\'", "")
+        path.gsub!(";", "")
+        path
+      end
+    end
+  end
+end

data/lib/deadfire/front_end/apply_node.rb

@@ -0,0 +1,44 @@
+# Frozen_string_literal: true
+
+module Deadfire
+  class ApplyNode
+    attr_reader :node, :mixin_names
+
+    def initialize(node, mixin_names)
+      # TODO: mixin name can be single or multiple names, separated by a comma
+      @node = node
+      @mixin_names = fetch_mixin_name_from(mixin_names)
+    end
+
+    def accept(visitor)
+      visitor.visit_apply_node(self)
+    end
+
+    def lineno
+      node.lineno
+    end
+
+    private
+
+    def fetch_mixin_name_from(tokens)
+      @_cached_mixin_name ||= begin
+        names = []
+        current = []
+        tokens.each do |token|
+          case token.type
+          when :comma
+            names << current.join("")
+            current = []
+            current << token.lexeme
+          when :whitespace
+            # ignore whitespace
+          else
+            current << token.lexeme
+          end
+        end
+        names << current.join("")
+        names
+      end
+    end
+  end
+end

data/lib/deadfire/front_end/at_rule_node.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Deadfire
+  module FrontEnd
+    class AtRuleNode < BaseNode
+      attr_reader :at_keyword, :value, :block
+
+      def initialize(at_keyword, value, block)
+        @at_keyword = at_keyword
+        @value = value
+        @block = block
+      end
+
+      def accept(visitor)
+        visitor.visit_at_rule_node(self)
+      end
+    end
+  end
+end

data/lib/deadfire/front_end/base_node.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Deadfire
+  module FrontEnd
+    class BaseNode
+      def accept
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/deadfire/front_end/block_node.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Deadfire
+  module FrontEnd
+    class BlockNode < BaseNode
+      attr_reader :declarations
+
+      def initialize
+        @declarations = []
+      end
+
+      def <<(node)
+        @declarations << node
+      end
+
+      def accept(visitor)
+        visitor.visit_block_node(self)
+      end
+    end
+  end
+end

data/lib/deadfire/front_end/comment_node.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Deadfire
+  module FrontEnd
+    class CommentNode < BaseNode
+      attr_reader :comment
+
+      def initialize(comment)
+        @comment = comment
+      end
+
+      def accept(visitor)
+        visitor.visit_comment_node(self)
+      end
+    end
+  end
+end

data/lib/deadfire/front_end/newline_node.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Deadfire
+  module FrontEnd
+    class NewlineNode < BaseNode
+      attr_reader :text
+
+      def initialize(text)
+        @text = text
+      end
+
+      def accept(visitor)
+        visitor.visit_newline_node(self)
+      end
+    end
+  end
+end