Rename Attribute_Selector to AttributeSelector

Author: mgreter

src/ast_fwd_decl.hpp

@@ -104,7 +104,7 @@ namespace Sass {
   class TypeSelector;
   class ClassSelector;
   class IDSelector;
-  class Attribute_Selector;
+  class AttributeSelector;
 
   class PseudoSelector;
 
@@ -201,7 +201,7 @@ namespace Sass {
   IMPL_MEM_OBJ(TypeSelector);
   IMPL_MEM_OBJ(ClassSelector);
   IMPL_MEM_OBJ(IDSelector);
-  IMPL_MEM_OBJ(Attribute_Selector);
+  IMPL_MEM_OBJ(AttributeSelector);
   IMPL_MEM_OBJ(PseudoSelector);
 
   IMPL_MEM_OBJ(SelectorComponent);

src/ast_sel_cmp.cpp

@@ -323,9 +323,9 @@ namespace Sass {
     return sel ? *this == *sel : false;
   }
 
-  bool Attribute_Selector::operator== (const SimpleSelector& rhs) const
+  bool AttributeSelector::operator== (const SimpleSelector& rhs) const
   {
-    auto sel = Cast<Attribute_Selector>(&rhs);
+    auto sel = Cast<AttributeSelector>(&rhs);
     return sel ? *this == *sel : false;
   }
 
@@ -361,7 +361,7 @@ namespace Sass {
     return name() == rhs.name();
   }
 
-  bool Attribute_Selector::operator== (const Attribute_Selector& rhs) const
+  bool AttributeSelector::operator== (const AttributeSelector& rhs) const
   {
     // smaller return, equal go on, bigger abort
     if (is_ns_eq(rhs)) {

src/ast_selectors.cpp

@@ -237,17 +237,17 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Attribute_Selector::Attribute_Selector(ParserState pstate, sass::string n, sass::string m, String_Obj v, char o)
+  AttributeSelector::AttributeSelector(ParserState pstate, sass::string n, sass::string m, String_Obj v, char o)
   : SimpleSelector(pstate, n), matcher_(m), value_(v), modifier_(o)
   { simple_type(ATTRIBUTE_SEL); }
-  Attribute_Selector::Attribute_Selector(const Attribute_Selector* ptr)
+  AttributeSelector::AttributeSelector(const AttributeSelector* ptr)
   : SimpleSelector(ptr),
     matcher_(ptr->matcher_),
     value_(ptr->value_),
     modifier_(ptr->modifier_)
   { simple_type(ATTRIBUTE_SEL); }
 
-  size_t Attribute_Selector::hash() const
+  size_t AttributeSelector::hash() const
   {
     if (hash_ == 0) {
       hash_combine(hash_, SimpleSelector::hash());
@@ -257,7 +257,7 @@ namespace Sass {
     return hash_;
   }
 
-  unsigned long Attribute_Selector::specificity() const
+  unsigned long AttributeSelector::specificity() const
   {
     return Constants::Specificity_Attr;
   }
@@ -1020,7 +1020,7 @@ namespace Sass {
 
   IMPLEMENT_AST_OPERATORS(Selector_Schema);
   IMPLEMENT_AST_OPERATORS(Placeholder_Selector);
-  IMPLEMENT_AST_OPERATORS(Attribute_Selector);
+  IMPLEMENT_AST_OPERATORS(AttributeSelector);
   IMPLEMENT_AST_OPERATORS(TypeSelector);
   IMPLEMENT_AST_OPERATORS(ClassSelector);
   IMPLEMENT_AST_OPERATORS(IDSelector);

src/ast_selectors.hpp

@@ -203,18 +203,18 @@ namespace Sass {
   ///////////////////////////////////////////////////
   // Attribute selectors -- e.g., [src*=".jpg"], etc.
   ///////////////////////////////////////////////////
-  class Attribute_Selector final : public SimpleSelector {
+  class AttributeSelector final : public SimpleSelector {
     ADD_CONSTREF(sass::string, matcher)
     // this cannot be changed to obj atm!!!!!!????!!!!!!!
     ADD_PROPERTY(String_Obj, value) // might be interpolated
     ADD_PROPERTY(char, modifier);
   public:
-    Attribute_Selector(ParserState pstate, sass::string n, sass::string m, String_Obj v, char o = 0);
+    AttributeSelector(ParserState pstate, sass::string n, sass::string m, String_Obj v, char o = 0);
     size_t hash() const override;
     virtual unsigned long specificity() const override;
     bool operator==(const SimpleSelector& rhs) const final override;
-    ATTACH_CMP_OPERATIONS(Attribute_Selector)
-    ATTACH_AST_OPERATIONS(Attribute_Selector)
+    ATTACH_CMP_OPERATIONS(AttributeSelector)
+    ATTACH_AST_OPERATIONS(AttributeSelector)
     ATTACH_CRTP_PERFORM_METHODS()
   };
 

src/debugger.hpp

@@ -432,9 +432,9 @@ inline void debug_ast(AST_Node* node, sass::string ind, Env* env)
     std::cerr << std::endl;
     debug_ast(selector->argument(), ind + " <= ", env);
     debug_ast(selector->selector(), ind + " || ", env);
-  } else if (Cast<Attribute_Selector>(node)) {
-    Attribute_Selector* selector = Cast<Attribute_Selector>(node);
-    std::cerr << ind << "Attribute_Selector " << selector;
+  } else if (Cast<AttributeSelector>(node)) {
+    AttributeSelector* selector = Cast<AttributeSelector>(node);
+    std::cerr << ind << "AttributeSelector " << selector;
     std::cerr << " (" << pstate_source_position(node) << ")";
     std::cerr << " <" << selector->hash() << ">";
     std::cerr << " <<" << selector->ns_name() << ">>";

src/eval.hpp

@@ -88,7 +88,7 @@ namespace Sass {
     IDSelector* operator()(IDSelector* s) { return s; };
     ClassSelector* operator()(ClassSelector* s) { return s; };
     TypeSelector* operator()(TypeSelector* s) { return s; };
-    Attribute_Selector* operator()(Attribute_Selector* s) { return s; };
+    AttributeSelector* operator()(AttributeSelector* s) { return s; };
     Placeholder_Selector* operator()(Placeholder_Selector* s) { return s; };
 
     // actual evaluated selectors

src/inspect.cpp

@@ -955,7 +955,7 @@ namespace Sass {
     append_token(s->ns_name(), s);
   }
 
-  void Inspect::operator()(Attribute_Selector* s)
+  void Inspect::operator()(AttributeSelector* s)
   {
     append_string("[");
     add_open_mapping(s);

src/inspect.hpp

@@ -85,7 +85,7 @@ namespace Sass {
     virtual void operator()(TypeSelector*);
     virtual void operator()(ClassSelector*);
     virtual void operator()(IDSelector*);
-    virtual void operator()(Attribute_Selector*);
+    virtual void operator()(AttributeSelector*);
     virtual void operator()(PseudoSelector*);
     virtual void operator()(SelectorComponent*);
     virtual void operator()(SelectorCombinator*);

src/operation.hpp

@@ -114,7 +114,7 @@ namespace Sass {
     virtual T operator()(TypeSelector* x)       = 0;
     virtual T operator()(ClassSelector* x)         = 0;
     virtual T operator()(IDSelector* x)            = 0;
-    virtual T operator()(Attribute_Selector* x)     = 0;
+    virtual T operator()(AttributeSelector* x)     = 0;
     virtual T operator()(PseudoSelector* x)        = 0;
     virtual T operator()(SelectorComponent* x) = 0;
     virtual T operator()(SelectorCombinator* x) = 0;
@@ -200,7 +200,7 @@ namespace Sass {
     T operator()(TypeSelector* x)       { return static_cast<D*>(this)->fallback(x); }
     T operator()(ClassSelector* x)         { return static_cast<D*>(this)->fallback(x); }
     T operator()(IDSelector* x)            { return static_cast<D*>(this)->fallback(x); }
-    T operator()(Attribute_Selector* x)     { return static_cast<D*>(this)->fallback(x); }
+    T operator()(AttributeSelector* x)     { return static_cast<D*>(this)->fallback(x); }
     T operator()(PseudoSelector* x)        { return static_cast<D*>(this)->fallback(x); }
     T operator()(SelectorComponent* x) { return static_cast<D*>(this)->fallback(x); }
     T operator()(SelectorCombinator* x) { return static_cast<D*>(this)->fallback(x); }

src/parser.cpp

@@ -821,17 +821,17 @@ namespace Sass {
     return sequence < insensitive<'i'>, re_attr_sensitive_close >(src);
   }
 
-  Attribute_Selector_Obj Parser::parse_attribute_selector()
+  AttributeSelectorObj Parser::parse_attribute_selector()
   {
     ParserState p = pstate;
     if (!lex_css< attribute_name >()) error("invalid attribute name in attribute selector");
     sass::string name(lexed);
     if (lex_css< re_attr_sensitive_close >()) {
-      return SASS_MEMORY_NEW(Attribute_Selector, p, name, "", {}, {});
+      return SASS_MEMORY_NEW(AttributeSelector, p, name, "", {}, {});
     }
     else if (lex_css< re_attr_insensitive_close >()) {
       char modifier = lexed.begin[0];
-      return SASS_MEMORY_NEW(Attribute_Selector, p, name, "", {}, modifier);
+      return SASS_MEMORY_NEW(AttributeSelector, p, name, "", {}, modifier);
     }
     if (!lex_css< alternatives< exact_match, class_match, dash_match,
                                 prefix_match, suffix_match, substring_match > >()) {
@@ -851,11 +851,11 @@ namespace Sass {
     }
 
     if (lex_css< re_attr_sensitive_close >()) {
-      return SASS_MEMORY_NEW(Attribute_Selector, p, name, matcher, value, 0);
+      return SASS_MEMORY_NEW(AttributeSelector, p, name, matcher, value, 0);
     }
     else if (lex_css< re_attr_insensitive_close >()) {
       char modifier = lexed.begin[0];
-      return SASS_MEMORY_NEW(Attribute_Selector, p, name, matcher, value, modifier);
+      return SASS_MEMORY_NEW(AttributeSelector, p, name, matcher, value, modifier);
     }
     error("unterminated attribute selector for " + name);
     return {}; // to satisfy compilers (error must not return)