deadfire 0.3.0 → 0.5.0

data/lib/deadfire/filename_helper.rb

@@ -5,18 +5,16 @@ module Deadfire
     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)
+        potential = potential_path(path)
+        ext = File.extname(path)
+
+        if ext && valid_file?(potential)
+          potential
+        else
+          possible_paths(path)
         end
-  
-        import_path
       end
-      
+
       def normalize_path(line)
         path = line.split.last
         path.gsub!("\"", "")
@@ -24,6 +22,28 @@ module Deadfire
         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

data/lib/deadfire/front_end/apply_node.rb

@@ -1,11 +1,10 @@
-# Frozen_string_literal: true
+# 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

data/lib/deadfire/front_end/parser.rb

@@ -13,19 +13,13 @@ module Deadfire
       end
 
       def parse
-        # top level it's a list of statements
-        # statements are either rules or at-rules
-        # rules are selectors + declarations
-        # at-rules are at-keyword + block
-        # block is a list of declarations?
-        # declarations are property + value
         while !is_at_end?
           if check(:comment)
             comment = add_comment
-            @stylesheet << comment if Deadfire.configuration.keep_comments
+            @stylesheet << comment unless Deadfire.configuration.compressed
           elsif check(:newline)
             newline = add_newline
-            @stylesheet << newline if Deadfire.configuration.keep_whitespace
+            @stylesheet << newline unless Deadfire.configuration.compressed
           elsif matches_at_rule?
             @stylesheet << at_rule_declaration
           else
@@ -84,10 +78,6 @@ module Deadfire
         check(:at_rule)
       end
 
-      def matches_nested_rule?
-        match?(:ampersand)
-      end
-
       def parse_block
         block = BlockNode.new
         block << previous
@@ -111,7 +101,11 @@ module Deadfire
       def ruleset_declaration
         values = []
         while !match?(:left_brace)
-          values << advance
+          unless match?(:comment)
+            values << advance
+          else
+            values << advance unless Deadfire.configuration.compressed
+          end
         end
 
         selector = SelectorNode.new(values[0..-1])
@@ -142,14 +136,16 @@ module Deadfire
 
         if previous.type == :semicolon
           if keyword.lexeme == "@apply"
-            return ApplyNode.new(keyword, values)
+            ApplyNode.new(keyword, values)
           else
             values << previous # add the semicolon to the values
-            return AtRuleNode.new(keyword, values, nil)
+            AtRuleNode.new(keyword, values, nil)
           end
+        elsif is_at_end?
+          AtRuleNode.new(keyword, values, nil)
+        else
+          AtRuleNode.new(keyword, values[0..-1], parse_block) # remove the left brace, because it's not a value, but part of the block
         end
-
-        AtRuleNode.new(keyword, values[0..-1], parse_block) # remove the left brace, because it's not a value, but part of the block
       end
     end
   end

data/lib/deadfire/front_end/scanner.rb

@@ -75,26 +75,15 @@ module Deadfire
       end
 
       def add_at_rule(literal = nil)
-        selector = [current_char]
-
-        while Spec::CSS_AT_RULES.none? { |kwrd| kwrd == selector.join + peek } && !at_end?
-          break if peek == NEWLINE
-          selector << advance
-        end
-
-        # final char in at-rule
-        selector << advance
-
-        current_at_rule = selector.join
-        at_rule = Spec::CSS_AT_RULES.find { |kwrd| kwrd == current_at_rule }
+        at_rule = determine_at_rule
 
         if peek == NEWLINE
           @line += 1
           @error_reporter.error(@line, "at-rule cannot be on multiple lines.")
-          add_token(:at_rule, current_at_rule)
+          add_token(:at_rule, at_rule)
         elsif at_rule
           token = add_token(:at_rule, "at_#{at_rule[1..-1]}")
-          if at_rule == "@import"
+          if at_rule == Spec::IMPORT
             prescan_import_rule(token.last)
           else
             token
@@ -172,32 +161,38 @@ module Deadfire
       end
 
       def add_forward_slash_or_comment
-        if peek == "*"
-          advance # consume the *
-          while peek != "*" && peek_next != "/" && !at_end?
-            @line += 1 if peek == NEWLINE
-            advance
-          end
+        return add_token(:forward_slash) unless peek == "*"
 
-          if at_end? && peek != "*"
+        advance # consume the *
+        while true
+          if at_end?
             @error_reporter.error(@line, "Unterminated comment on line #{@line}.")
-          else
-            advance # consume the *
-            advance # consume the /
+            break
           end
-          add_token(:comment) # Add the comment anyway, but report an error.
-        else
-          add_token(:forward_slash)
+
+          case peek
+          when NEWLINE
+            @line += 1
+          when "*"
+            if peek_next == "/"
+              advance # consume the *
+              advance # consume the /
+              break
+            end
+          end
+
+          advance
         end
+        add_token(:comment) # Add the comment anyway, but report an error.
       end
 
       def add_whitespace_token
-        add_token(:whitespace) if Deadfire.configuration.keep_whitespace
+        add_token(:whitespace) unless Deadfire.configuration.compressed
       end
 
       def add_newline_token
         @line += 1
-        add_token(:newline) if Deadfire.configuration.keep_whitespace
+        add_token(:newline) unless Deadfire.configuration.compressed
       end
 
       def current_char_position
@@ -229,6 +224,21 @@ module Deadfire
         (char >= "a" && char <= "z") || (char >= "A" && char <= "Z")
       end
 
+      def determine_at_rule
+        selector = [current_char]
+
+        while Spec::CSS_AT_RULES.none? { |kwrd| kwrd == selector.join + peek } && !at_end?
+          break if peek == NEWLINE
+          selector << advance
+        end
+
+        # final char in at-rule
+        selector << advance
+
+        current_at_rule = selector.join
+        Spec::CSS_AT_RULES.find { |kwrd| kwrd == current_at_rule }
+      end
+
       def prescan_import_rule(token)
         # we want to get all the text between the @import and the semicolon
         # so we can parse the file and add it to the ast
@@ -237,29 +247,33 @@ module Deadfire
         while peek != ";" && !at_end?
           advance
         end
+        
+        add_token(:text)
 
         if at_end?
-          @error_reporter.error(@line, "Unterminated import rule.")
+          @error_reporter.error(@line, "Imports must be terminated correctly with a ';'.")
           return
         end
 
-        add_token(:text)
-        advance # remove the semicolon
-
         text_token = @tokens.last
 
         text = text_token.lexeme.gsub(/\\|"/, '')
         file = FilenameHelper.resolve_import_path(text, @line)
 
-        # file is ready for scanning
-        content = File.read(file)
-        scanner = Scanner.new(content, @error_reporter)
+        if file
+          # file is ready for scanning
+          content = File.read(file)
+          scanner = Scanner.new(content, @error_reporter)
 
-        @tokens.pop # remove the text token
-        @tokens.pop # remove the at_rule token
+          advance # remove the semicolon
+          @tokens.pop # remove the text token
+          @tokens.pop # remove the at_rule token
 
-        imported_tokens = scanner.tokenize[0..-2]
-        @tokens.concat imported_tokens
+          imported_tokens = scanner.tokenize[0..-2]
+          @tokens.concat imported_tokens
+        else
+          @error_reporter.error(@line, "File not found '#{text}'")
+        end
       end
     end
   end

data/lib/deadfire/front_end/stylesheet_node.rb

@@ -13,7 +13,7 @@ module Deadfire
         visitor.visit_stylesheet_node(self)
       end
 
-      def << (node)
+      def <<(node)
         @statements << node
       end
     end

data/lib/deadfire/interpreter.rb

@@ -1,12 +1,10 @@
-# Frozen_string_literal: true
+# frozen_string_literal: true
 
 module Deadfire
   class Interpreter # :nodoc:
-    singleton_class.attr_accessor :cached_apply_rules
-    self.cached_apply_rules = Hash.new { |h, k| h[k] = nil }
-
-    def initialize(error_reporter)
+    def initialize(error_reporter, asset_loader)
       @error_reporter = error_reporter
+      @asset_loader = asset_loader
     end
 
     def interpret(node)
@@ -27,8 +25,8 @@ module Deadfire
       if node.block
         visit_block_node(node.block, node)
 
-        unless Interpreter.cached_apply_rules[node.selector.selector]
-          Interpreter.cached_apply_rules[node.selector.selector] = node.block if node.selector.cacheable?
+        unless @asset_loader.cached_css(node.selector.selector)
+          @asset_loader.cache_css(node.selector.selector, node.block) if node.selector.cacheable?
         end
       end
     end
@@ -44,10 +42,6 @@ module Deadfire
       end
     end
 
-    def visit_declaration_node(node)
-      node.accept(self)
-    end
-
     def visit_comment_node(node)
       # node.accept(self)
     end
@@ -64,9 +58,7 @@ module Deadfire
     def apply_mixin(mixin, node)
       updated_declarations = []
       mixin.mixin_names.each do |mixin_name|
-        if Interpreter.cached_apply_rules[mixin_name]
-          cached_block = Interpreter.cached_apply_rules[mixin_name]
-
+        if cached_block = @asset_loader.cached_css(mixin_name)
           # NOTE: remove the left and right brace but we probably don't need to do this, how can this be simplified?
           cached_block.declarations[1...-1].each do |cached_declaration|
             updated_declarations << cached_declaration

data/lib/deadfire/mixin_parser.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Deadfire
+  class MixinParser # :nodoc:
+    attr_reader :mixins
+
+    def initialize
+      @mixins = {}
+    end
+
+    def interpret(node)
+      node.accept(self)
+    end
+
+    def visit_stylesheet_node(node)
+      node.statements.each { |child| child.accept(self) }
+    end
+
+    def visit_at_rule_node(node)
+      if node.block
+        visit_block_node(node.block, node)
+      end
+    end
+
+    def visit_ruleset_node(node)
+      if node.block
+        visit_block_node(node.block, node)
+
+        if node.selector.cacheable?
+          if @mixins.key?(node.selector.selector)
+            Deadfire.config.logger.warn("Mixin '#{node.selector.selector}' will be overrided with a new value.")
+          end
+
+          @mixins[node.selector.selector] = node.block
+        end
+      end
+    end
+
+    def visit_block_node(node, parent)
+    end
+
+    def visit_comment_node(node)
+    end
+
+    def visit_apply_node(node)
+    end
+
+    def visit_newline_node(node)
+    end
+  end
+end

data/lib/deadfire/parser_engine.rb

@@ -7,12 +7,13 @@ module Deadfire
     def initialize(content, options = {})
       @error_reporter = ErrorReporter.new
       @options = {}
+      @asset_loader = AssetLoader.new(options[:filename])
       @scanner = FrontEnd::Scanner.new(content, error_reporter)
     end
 
     def parse
       ast = _parse
-      interpreter = Interpreter.new(error_reporter)
+      interpreter = Interpreter.new(error_reporter, @asset_loader)
       ast.statements.each do |node|
         interpreter.interpret(node)
       end
@@ -31,6 +32,15 @@ module Deadfire
       @error_reporter.errors?
     end
 
+    def load_mixins
+      ast = _parse
+      parser = MixinParser.new
+      ast.statements.each do |node|
+        parser.interpret(node)
+      end
+      parser.mixins
+    end
+
     private
 
     def _parse

data/lib/deadfire/railtie.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+require "rails"
+require "propshaft"
+
+module Deadfire
+  class Railties < ::Rails::Railtie
+    config.deadfire = ActiveSupport::OrderedOptions.new
+    config.deadfire.root_path = nil
+    config.deadfire.excluded_files = []
+
+    initializer :deadfire do |app|
+      Deadfire.configure do |deadfire_config|
+        deadfire_config.root_path = config.deadfire.root_path || app.root.join("app", "assets", "stylesheets")
+        deadfire_config.excluded_files = config.deadfire.excluded_files
+        deadfire_config.compressed = config.assets.compressed
+        deadfire_config.logger = config.assets.logger || Rails.logger
+      end
+    end
+
+    class DeadfireCompiler < ::Propshaft::Compiler
+      def compile(logical_path, input)
+        path = logical_path.path.to_s
+
+        return input if Deadfire.config.excluded_files.include?(path)
+
+        # by default, all files in the will be preprocessed
+        if Deadfire.config.asset_registry.settings.empty?
+          all_files = Dir.glob("#{Deadfire.config.root_path}/**/*.css")
+          Deadfire.config.preprocess(*all_files)
+        end
+
+        Deadfire.parse(input, filename: logical_path.logical_path.to_s)
+      end
+    end
+  
+    config.assets.compilers << ["text/css", DeadfireCompiler]
+  end
+end

data/lib/deadfire/spec.rb

@@ -17,35 +17,36 @@ module Deadfire
     # value              = any-value [ ',' S* any-value ]*;
     # any-value          = IDENT | STRING | NUMBER | PERCENTAGE | DIMENSION | COLOR | URI | FUNCTION any-value* ')' | '(' any-value* ')' | '[' any-value* ']' | '{' any-value* '}' | ';';
 
-    # -- SASS features
-
-    # Example: @apply button;
-    # apply-rule = "@apply" S* mixin-name S* ";" S*
-    # mixin-name = IDENT
-
-    # Example: button { color: red; &.active { color: blue } }
-    # nested-selector = selector S* "{" S* declaration-list S* "}"
-    # selector = simple-selector [ "&" simple-selector ]
-    # simple-selector = element-name [ "#" id ] [ "." class ]*
-    # element-name = IDENT
-    # id = IDENT
-    # class = "." IDENT
-    # declaration-list = declaration [ ";" S* declaration ]*
+    CHARSET = "@charset"
+    IMPORT = "@import"
+    MEDIA = "@media"
+    PAGE = "@page"
+    FONT_FACE = "@font-face"
+    KEYFRAMES = "@keyframes"
+    WEBKIT_KEYFRAMES = "@-webkit-keyframes"
+    SUPPORTS = "@supports"
+    NAMESPACE = "@namespace"
+    COUNTER_STYLE = "@counter-style"
+    VIEWPORT = "@viewport"
+    DOCUMENT = "@document"
+    APPLY = "@apply"
+    LAYER = "@layer"
 
     CSS_AT_RULES = [
-      "@charset",
-      "@import",
-      "@media",
-      "@page",
-      "@font-face",
-      "@keyframes",
-      "@supports",
-      "@namespace",
-      "@counter-style",
-      "@viewport",
-      "@document",
-      "@apply",
-      "@layer"
+      CHARSET,
+      IMPORT,
+      MEDIA,
+      PAGE,
+      FONT_FACE,
+      KEYFRAMES,
+      WEBKIT_KEYFRAMES,
+      SUPPORTS,
+      NAMESPACE,
+      COUNTER_STYLE,
+      VIEWPORT,
+      DOCUMENT,
+      APPLY,
+      LAYER
     ]
 
     CSS_SELECTORS = [

data/lib/deadfire/version.rb

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

data/lib/deadfire.rb

@@ -1,13 +1,14 @@
 # frozen_string_literal: true
 
 require_relative "deadfire/ast_printer"
-require_relative "deadfire/css_buffer"
+require_relative "deadfire/asset_loader"
+require_relative "deadfire/asset_registry"
 require_relative "deadfire/css_generator"
 require_relative "deadfire/configuration"
 require_relative "deadfire/errors"
 require_relative "deadfire/error_reporter"
 require_relative "deadfire/interpreter"
-require_relative "deadfire/parser"
+require_relative "deadfire/mixin_parser"
 require_relative "deadfire/parser_engine"
 require_relative "deadfire/spec"
 require_relative "deadfire/filename_helper"
@@ -26,6 +27,8 @@ require_relative "deadfire/front_end/selector_node"
 require_relative "deadfire/front_end/stylesheet_node"
 
 module Deadfire
+  PERMISSIBLE_FILE_EXTENSIONS = [".css", ".scss"].freeze
+
   class << self
     attr_reader :config
 
@@ -42,9 +45,15 @@ module Deadfire
     end
 
     def parse(content, options = {})
-      parser = ParserEngine.new(content)
-      # TODO: hook into a logger and report the errors
+      configure do |config|
+        config.root_path = options[:root_path]
+        config.compressed = options[:compressed]
+      end
+
+      parser = ParserEngine.new(content, filename: options[:filename])
       parser.parse
     end
   end
 end
+
+require_relative "deadfire/railtie"