css-native 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 755affad3180d9aa85746a5f471a5f339b4d377c78e87c33450391639c82844a
-  data.tar.gz: 91378f2f7a663c8b74519abf0473c40c99018553dbc19861ad34593d8bc44be6
+  metadata.gz: b43f3acebaa6a120dbf30767223cf2ad94c7517498d4e0df41a5b4b6b95a7bb9
+  data.tar.gz: d2333285b9a95b1ef6ef396c4005bc44e9a6b19e7e9ced18e623b1e81d9f090b
 SHA512:
-  metadata.gz: f50f885a37fd7e92bbf560d5fc56e55033fa0e6baabf54babc81d65b473bdfe394343c49a0901d0c099939f2e16e54349b78d7021969719dbd0b535c9e78e948
-  data.tar.gz: caf0bcd21952347361973ea9a6d5ce3a93cad0f777773f4cb77f7738f6327abcda7e99b6e3b874bfa65eeaab54dde09723f5c5a8e8324e860b92d4ee89746fd1
+  metadata.gz: 5d2c91d4ac29d3ef89eacfa52829277feae315397aae88c47a9825603cc4dc4bfbd4c1167c402f3c8de52bdac85639b5a158785a22a53c2ec8bf61243fe4ec9b
+  data.tar.gz: fdb8421c46210b287ce282a9caa8df4b2e049367540e87f26606609e5a6134ef9e1ad8de1c36c4ea084541ff4a44d2b710e55d3349b98863a3101765c4e3b79b

data/lib/css-native.rb

@@ -9,33 +9,6 @@ class CSSNative
     sheet
   end
   
-  def self.format_element(name)
-    name.to_s
-  end
-
-  def self.format_class(name)
-    ".#{name}"
-  end
-
-  def self.format_id(name)
-    "##{name}"
-  end
-
-  def self.format_attribute(name, operation = :none, value = nil, case_sensitive: true)
-    op = case operation.to_sym
-         when :none        then ""
-         when :equals      then "="
-         when :include     then "~="
-         when :matches     then "|="
-         when :starts_with then "^="
-         when :ends_with   then "$="
-         when :contains    then "*="
-         else
-           raise AttributeError.new("undefined comparison '#{operation}' for css attribute selector")
-         end
-    "[#{name}#{op}#{value.nil? ? "" : "\"#{value}\""}#{case_sensitive ? "" : " i"}]"
-  end
-
   attr_reader :rules
   def initialize
     @rules = []
@@ -73,7 +46,7 @@ class CSSNative
     when :attribute
       attribute(name, *args)
     else
-      raise RuleError.new("undefined rule type '#{type}' for css selector")
+      raise RuleError.new(rule: type)
     end
   end
 

data/lib/css-native/errors.rb

@@ -1,16 +1,53 @@
 class CSSNative
   class CSSError < StandardError
+    def initialize(msg = "Invalid CSS")
+      super(msg)
+    end
   end
   
   class RuleError < CSSError
+    def initialize(msg = "Invalid rule type", rule: nil)
+      if rule.nil?
+        super(msg)
+      else
+        super("Invalid rule type '#{rule}'")
+      end
+    end
   end
-  
-  class GrammarError < RuleError
-    def initialize(element = nil)
-      super("Rule selector#{element.nil? ? "" : " #{element}"} not valid in current position")
+
+  class AttributeError < CSSError
+    def initialize(msg = "Invalid attribute structure")
+      super(msg)
+    end
+  end
+
+  class AttributeComparisonError < AttributeError
+    def initialize(msg = "Invalid attrubute comparison", comparison: nil)
+      if comparison.nil?
+        super(msg)
+      else
+        super(msg + " '#{comparison}'")
+      end
     end
   end
   
+  class SelectorError < RuleError
+    def initialize(msg = "Selector not valid", element: nil, previous: nil)
+      if element.nil? && previous.nil?
+        super(msg)
+      elsif previous.nil?
+        super("Selector '#{element}' not valid")
+      else
+        super("Selector '#{element}' not valid after '#{previous}' selector part")
+      end
+    end
+  end
+
+  class JoinError < RuleError
+    def initialize(msg = "Cannot join a rule to a non-rule")
+      super(msg)
+    end
+  end  
   class PseudoClassError < RuleError
     def initialize(msg = "invalid pseudo-class", argument: nil, method: nil)
       if argument.nil? && method.nil?
@@ -34,7 +71,4 @@ class CSSNative
       end
     end
   end
-
-  class AttributeError < CSSError
-  end
 end

data/lib/css-native/rule.rb

@@ -1,4 +1,5 @@
 require "css-native/rule/stylesheet"
+require "css-native/rule/constants"
 class CSSNative
   class Rule
     def initialize(parent, name = "", previous: nil)
@@ -10,27 +11,23 @@ class CSSNative
 
     # basic selectors
     def with_element(name, &block)
-      raise GrammarError.new(name) if previous_selector?
-      @previous = :element
-      @selector += CSSNative::format_element(name)
+      selector_error(name) if previous_selector?
+      append_selector(format_element(name), :element)
       chain(&block)
     end
 
     def with_class(name, &block)
-      @previous = :class
-      @selector += CSSNative::format_class(name)
+      append_selector(format_class(name), :class)
       chain(&block)
     end
 
     def with_id(name, &block)
-      @previous = :id
-      @selector += CSSNative::format_id(name)
+      append_selector(format_id(name), :id)
       chain(&block)
     end
 
-    def with_attribute(name, operation = :none, value = nil, case_sensitive: true, &block)
-      @previous = :attribute
-      @selector += CSSNative::format_attribute(name, operation, value, case_sensitive: case_sensitive)
+    def with_attribute(name, op = :none, value = nil, case_sensitive: true, &block)
+      append_selector(format_attribute(name, op, value, case_sensitive: case_sensitive), :attribute)
       chain(&block)
     end
 
@@ -49,166 +46,68 @@ class CSSNative
       when :attribute
         with_attribute(name, *args, &block)
       else
-        raise CSSNative::RuleError.new("undefined rule type '#{type}' for css selector")
+        raise RuleError.new("undefined rule type '#{type}' for css selector")
       end
     end
     alias_method :select, :with
 
     def all(&block)
-      raise GrammarError.new("*") if previous_selector?
-      @previous = :all
-      @selector += "*"
+      selector_error("*") if previous_selector?
+      append_selector("*", :all)
       chain(&block)
     end
 
     # Grouping selectors
-    def join(rule = nil)
-      raise GrammarError.new(",") if previous_combinator?
-      @previous = :join
-      @selector += ","
+    def join(rule = nil, &block)
+      raise JoinError unless rule.kind_of?(Rule) || rule.nil?
+      selector_error(",") if previous_combinator?
+
       if rule.kind_of? Rule
-        @selector += rule.instance_variable_get(:@selector)
+        selector = rule.instance_variable_get(:@selector)
+        previous = rule.instance_variable_get(:@previous)
+
+        append_selector("," + selector, previous)
+        previous_combinator? ? self : chain(&block)
       else
-        @selector += rule.to_s
+        append_selector(",", :join)
+        self
       end
-      self
     end
 
     # Combinators
-    COMBINATORS = {
-      descendant: " ",
-      child: " > ",
-      sibling: " + ",
-      adjacent: " + ",
-      column: " || "
-    }
-
     def combinator(c)
       m = c.to_sym
-      raise GrammarError.new(COMBINATORS[m].strip) if previous_combinator?
-      @previous = :combinator
-      @selector += COMBINATORS[m]
+      selector_error(COMBINATORS[m].strip) if previous_combinator?
+      append_selector(COMBINATORS[m], :combinator)
       self
     end
 
-    # pseudo-classes
-    # name of value is pseudo-class, array values are acceptad options
-    #   Equality is compared by <option> === <value>, allowing 
-    #   classes to test for instances or regex matching
-    # If array is empty, there's no limitations (in the code, foraml CSS may differ)
-    # If array is nil, it takes no options
-    PSEUDO_CLASSES = {
-      # Linguistic
-      dir: ["ltr", "rtl"],
-      lang: [],
-      # Location
-      "any_link": nil,
-      link: nil,
-      visited: nil,
-      "local_link": nil,
-      target: nil,
-      "target_within": nil,
-      scope: nil,
-      # User action
-      hover: nil,
-      active: nil,
-      focus: nil,
-      "focus_visible": nil,
-      "focus_within": nil,
-      # Time_dimensional _ ill_defined
-      current: nil,
-      past: nil,
-      future: nil,
-      # Resource state
-      playing: nil,
-      paused: nil,
-      # Input
-      enabled: nil,
-      disabled: nil,
-      "read_only": nil,
-      "read_write": nil,
-      "placeholder_shown": nil,
-      default: nil,
-      checked: nil,
-      indeterminate: nil,
-      blank: nil,
-      valid: nil,
-      invalid: nil,
-      "in_range": nil,
-      "out_of_range": nil,
-      required: nil,
-      optional: nil,
-      "user_invalid": nil,
-      root: nil,
-      empty: nil,
-      "nth_child": ["odd", "even", /^\d+(n(\s*\+\s*\d+)?)?$/],
-      "nth_last_child": ["odd", "even", /^\d+(n(\s*\+\s*\d+)?)?$/],
-      "first_child": nil,
-      "last_child": nil,
-      "only_child": nil,
-      "nth_of_type": ["odd", "even", /^\d+(n(\s*\+\s*\d+)?)?$/],
-      "nth_last_of_type": ["odd", "even", /^\d+(n(\s*\+\s*\d+)?)?$/],
-      "first_of_type": nil,
-      "last_of_type": nil,
-      "only_of_type": nil,
-    }
-   
     def pseudo_class(name, *args, &block)
       pc = name.to_s.gsub("_", "-")
       m = name.to_s.gsub("-", "_").to_sym
       raise PseudoClassError.new(method: pc) unless PSEUDO_CLASSES.key?(m)
 
-      args.each? do |arg|
-        unless matches_arg_defs?(PSEUDO_CLASSES[m], arg.to_s)
-          raise PseudoClassError.new(argument: arg, method: pc)
-        end
+      unless args.all? {|arg| valid_arg?(PSEUDO_CLASSES[m], arg.to_s)}
+        raise PseudoClassError.new(argument: arg, method: pc) 
       end
       
-      @previous = :pseudo_class
-      @selector += ":#{pc}"
-      @selector += "(#{args.join(" ")})" unless args.empty?
+      selector = ":#{pc}" + (args.empty? ? "" : "(#{args.join(" ")})")
+      append_selector(selector, :pseudo_class)
       chain(&block)
     end
 
-    # pseudo-elements
-    # definition semantics same as pseudo-classes
-    PSEUDO_ELEMENTS = {
-      after: nil,
-      before: nil,
-      backdrop: nil,
-      cue: nil,
-      "cue_region": nil,
-      "first_letter": nil,
-      "first_line": nil,
-      "file_selector_button": nil,
-      "grammar_error": nil,
-      marker: nil,
-      part: [/[-a-zA-Z]+( [-a-zA-Z]+)?/],
-      placeholder: nil,
-      selection: nil,
-      slotted: [],
-      "spelling_error": nil,
-      "target_text": nil,
-    }
-
     def pseudo_element(name, *args, &block)
       pe = name.to_s.gsub("_", "-")
       m = name.to_s.gsub("-", "_").to_sym
       raise PseudoElementError.new(method: pe) unless PSEUDO_ELEMENTS.key?(m)
      
-      args.each? do |arg|
-        unless matches_arg_defs?(PSEUDO_ELEMENTS[m], arg.to_s)
-          raise PseudoElementError.new(argument: arg, method: pe)
-        end
+      unless args.all? {|arg| valid_arg?(PSEUDO_ELEMENTS[m], arg.to_s)}
+        raise PseudoElementError.new(argument: arg, method: pe)
       end
-      
-      @previous = :pseudo_element
-      @selector += "::#{pe}"
-      @selector += "(#{args.join(" ")})" unless args.empty?
 
-      # Not "chain" because a pseudo-element is always the final selector
-      @stylesheet.instance_exec(@stylesheet, &block)
-      @parent.rules << to_s 
+      selector = "::#{pe}" + (args.empty? ? "" : "(#{args.join(" ")})")
+      append_selector(selector, :pseudo_element)
+      chain(&block)
     end
 
     def method_missing(m, *args, &block)
@@ -259,12 +158,51 @@ class CSSNative
       end
     end
 
-    def matches_arg_defs?(defs, arg)
+    def append_selector(item, symbol)
+      @selector += item
+      @previous = symbol
+    end
+
+    def selector_error(name)
+      raise SelectorError.new(element: name, previous: @previous)
+    end
+
+    def valid_arg?(defs, arg)
       if defs.nil?
         arg.nil?
       else
         defs.empty? || defs.any? {|d| d === arg}
       end
     end
+    
+    def format_element(name)
+      name.to_s
+    end
+
+    def format_class(name)
+      ".#{name}"
+    end
+
+    def format_id(name)
+      "##{name}"
+    end
+
+    def format_attribute(name, operation = :none, value = nil, case_sensitive: true)
+      # Other case not possible because of positional arguments
+      raise AttributeError if operation != :none && value.nil?
+
+      op = case operation.to_sym
+           when :none        then ""
+           when :equals      then "="
+           when :include     then "~="
+           when :matches     then "|="
+           when :starts_with then "^="
+           when :ends_with   then "$="
+           when :contains    then "*="
+           else
+             raise AttributeComparisonError.new(operation: operation)
+           end
+      "[#{name}#{op}#{value.nil? ? "" : "\"#{value}\""}#{case_sensitive ? "" : " i"}]"
+    end
   end
 end

data/lib/css-native/rule/constants.rb

@@ -0,0 +1,96 @@
+class CSSNative
+  class Rule
+    private
+
+    COMBINATORS = {
+      descendant: " ",
+      child: " > ",
+      sibling: " + ",
+      adjacent: " + ",
+      column: " || "
+    }
+    
+    # pseudo-classes
+    # name of value is pseudo-class, array values are acceptad options
+    #   Equality is compared by <option> === <value>, allowing 
+    #   classes to test for instances or regex matching
+    # If array is empty, there's no limitations (in the code, foraml CSS may differ)
+    # If array is nil, it takes no options
+    PSEUDO_CLASSES = {
+      # Linguistic
+      dir: ["ltr", "rtl"],
+      lang: [],
+      # Location
+      "any_link": nil,
+      link: nil,
+      visited: nil,
+      "local_link": nil,
+      target: nil,
+      "target_within": nil,
+      scope: nil,
+      # User action
+      hover: nil,
+      active: nil,
+      focus: nil,
+      "focus_visible": nil,
+      "focus_within": nil,
+      # Time_dimensional _ ill_defined
+      current: nil,
+      past: nil,
+      future: nil,
+      # Resource state
+      playing: nil,
+      paused: nil,
+      # Input
+      enabled: nil,
+      disabled: nil,
+      "read_only": nil,
+      "read_write": nil,
+      "placeholder_shown": nil,
+      default: nil,
+      checked: nil,
+      indeterminate: nil,
+      blank: nil,
+      valid: nil,
+      invalid: nil,
+      "in_range": nil,
+      "out_of_range": nil,
+      required: nil,
+      optional: nil,
+      "user_invalid": nil,
+      root: nil,
+      empty: nil,
+      "nth_child": ["odd", "even", /^\d+(n(\s*\+\s*\d+)?)?$/],
+      "nth_last_child": ["odd", "even", /^\d+(n(\s*\+\s*\d+)?)?$/],
+      "first_child": nil,
+      "last_child": nil,
+      "only_child": nil,
+      "nth_of_type": ["odd", "even", /^\d+(n(\s*\+\s*\d+)?)?$/],
+      "nth_last_of_type": ["odd", "even", /^\d+(n(\s*\+\s*\d+)?)?$/],
+      "first_of_type": nil,
+      "last_of_type": nil,
+      "only_of_type": nil,
+    }
+
+    # pseudo-elements
+    # definition semantics same as pseudo-classes
+    PSEUDO_ELEMENTS = {
+      after: nil,
+      before: nil,
+      backdrop: nil,
+      cue: nil,
+      "cue_region": nil,
+      "first_letter": nil,
+      "first_line": nil,
+      "file_selector_button": nil,
+      "grammar_error": nil,
+      marker: nil,
+      part: [/[-a-zA-Z]+( [-a-zA-Z]+)?/],
+      placeholder: nil,
+      selection: nil,
+      slotted: [],
+      "spelling_error": nil,
+      "target_text": nil,
+    }
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: css-native
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Kellen Watt
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-02-10 00:00:00.000000000 Z
+date: 2021-02-12 00:00:00.000000000 Z
 dependencies: []
 description: A CSS generator designed to make writing CSS-compatible code cleaner
   and easier to undestand
@@ -20,6 +20,7 @@ files:
 - lib/css-native.rb
 - lib/css-native/errors.rb
 - lib/css-native/rule.rb
+- lib/css-native/rule/constants.rb
 - lib/css-native/rule/stylesheet.rb
 homepage: https://github.com/KellenWatt/css-native
 licenses: