nano-clean-pkg 0.0.1

data/rouge-5.0.0/lib/rouge/lexers/objective_c/common.rb

@@ -0,0 +1,182 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    module ObjectiveCCommon
+      def at_keywords
+        @at_keywords ||= %w(
+          selector private protected public encode synchronized try
+          throw catch finally end property synthesize dynamic optional
+          interface implementation import autoreleasepool
+        )
+      end
+
+      def at_builtins
+        @at_builtins ||= %w(true false YES NO)
+      end
+
+      def builtins
+        @builtins ||= %w(YES NO nil)
+      end
+
+      def self.extended(base)
+        base.prepend :statements do
+          rule %r/@"/, base::Str, :string
+          rule %r/@'(\\[0-7]{1,3}|\\x[a-fA-F0-9]{1,2}|\\.|[^\\'\n]')/,
+            base::Str::Char
+          rule %r/@(\d+[.]\d*|[.]\d+|\d+)e[+-]?\d+l?/i,
+            base::Num::Float
+          rule %r/@(\d+[.]\d*|[.]\d+|\d+f)f?/i, base::Num::Float
+          rule %r/@0x\h+[lL]?/, base::Num::Hex
+          rule %r/@0[0-7]+l?/i, base::Num::Oct
+          rule %r/@\d+l?/, base::Num::Integer
+          rule %r/\bin\b/, base::Keyword
+
+          rule %r/@(?:interface|implementation)\b/, base::Keyword, :objc_classname
+          rule %r/@(?:class|protocol)\b/, base::Keyword, :forward_classname
+
+          rule %r/@([[:alnum:]]+)/ do |m|
+            if base.at_keywords.include? m[1]
+              token base::Keyword
+            elsif base.at_builtins.include? m[1]
+              token base::Name::Builtin
+            else
+              token base::Error
+            end
+          end
+
+          rule %r/[?]/, base::Punctuation, :ternary
+          rule %r/\[/,  base::Punctuation, :message
+          rule %r/@\[/, base::Punctuation, :array_literal
+          rule %r/@\{/, base::Punctuation, :dictionary_literal
+        end
+
+        id = /[a-z$_][a-z0-9$_]*/i
+
+        base.state :ternary do
+          rule %r/:/, base::Punctuation, :pop!
+          mixin :statements
+        end
+
+        base.state :message_shared do
+          rule %r/\]/, base::Punctuation, :pop!
+          rule %r/\{/, base::Punctuation, :pop!
+          rule %r/;/, base::Error
+
+          mixin :statements
+        end
+
+        base.state :message do
+          rule %r/(#{id})(\s*)(:)/ do
+            groups(base::Name::Function, base::Text, base::Punctuation)
+            goto :message_with_args
+          end
+
+          rule %r/(#{id})(\s*)(\])/ do
+            groups(base::Name::Function, base::Text, base::Punctuation)
+            pop!
+          end
+
+          mixin :message_shared
+        end
+
+        base.state :message_with_args do
+          rule %r/\{/, base::Punctuation, :function
+          rule %r/(#{id})(\s*)(:)/ do
+            groups(base::Name::Function, base::Text, base::Punctuation)
+            pop!
+          end
+
+          mixin :message_shared
+        end
+
+        base.state :array_literal do
+          rule %r/]/, base::Punctuation, :pop!
+          rule %r/,/, base::Punctuation
+          mixin :statements
+        end
+
+        base.state :dictionary_literal do
+          rule %r/}/, base::Punctuation, :pop!
+          rule %r/,/, base::Punctuation
+          mixin :statements
+        end
+
+        base.state :objc_classname do
+          mixin :whitespace
+
+          rule %r/(#{id})(\s*)(:)(\s*)(#{id})/ do
+            groups(base::Name::Class, base::Text,
+                   base::Punctuation, base::Text,
+                   base::Name::Class)
+            pop!
+          end
+
+          rule %r/(#{id})(\s*)([(])(\s*)(#{id})(\s*)([)])/ do
+            groups(base::Name::Class, base::Text,
+                   base::Punctuation, base::Text,
+                   base::Name::Label, base::Text,
+                   base::Punctuation)
+            pop!
+          end
+
+          rule id, base::Name::Class, :pop!
+        end
+
+        base.state :forward_classname do
+          mixin :whitespace
+
+          rule %r/(#{id})(\s*)(,)(\s*)/ do
+            groups(base::Name::Class, base::Text, base::Punctuation, base::Text)
+            push
+          end
+
+          rule %r/(#{id})(\s*)(;?)/ do
+            groups(base::Name::Class, base::Text, base::Punctuation)
+            pop!
+          end
+        end
+
+        base.prepend :root do
+          rule %r(
+            ([-+])(\s*)
+            ([(].*?[)])?(\s*)
+            (?=#{id}:?)
+          )ix do |m|
+            token base::Keyword, m[1]
+            token base::Text, m[2]
+            recurse(m[3]) if m[3]
+            token base::Text, m[4]
+            push :method_definition
+          end
+        end
+
+        base.state :method_definition do
+          rule %r/,/, base::Punctuation
+          rule %r/[.][.][.]/, base::Punctuation
+          rule %r/([(].*?[)])(#{id})/ do |m|
+            recurse m[1]; token base::Name::Variable, m[2]
+          end
+
+          rule %r/(#{id})(\s*)(:)/m do
+            groups(base::Name::Function, base::Text, base::Punctuation)
+          end
+
+          rule %r/;/, base::Punctuation, :pop!
+
+          rule %r/{/ do
+            token base::Punctuation
+            goto :function
+          end
+
+          mixin :inline_whitespace
+          rule %r(//.*?\n), base::Comment::Single
+          rule %r/\s+/m, base::Text
+
+          rule(//) { pop! }
+        end
+      end
+    end
+  end
+end

data/rouge-5.0.0/lib/rouge/lexers/objective_c.rb

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+require_relative 'c'
+require_relative 'objective_c/common'
+
+module Rouge
+  module Lexers
+    class ObjectiveC < C
+      extend ObjectiveCCommon
+
+      tag 'objective_c'
+      title "Objective-C"
+      desc 'an extension of C commonly used to write Apple software'
+      aliases 'objc', 'obj-c', 'obj_c', 'objectivec', 'objective-c'
+      filenames '*.m', '*.h'
+
+      mimetypes 'text/x-objective_c', 'application/x-objective_c'
+    end
+  end
+end

data/rouge-5.0.0/lib/rouge/lexers/objective_cpp.rb

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+require_relative 'cpp'
+require_relative 'objective_c/common'
+
+module Rouge
+  module Lexers
+
+    class ObjectiveCpp < Cpp
+      extend ObjectiveCCommon
+
+      tag 'objective_cpp'
+      title "Objective-C++"
+      desc 'an extension of C++ uncommonly used to write Apple software'
+      aliases 'objcpp', 'obj-cpp', 'obj_cpp', 'objectivecpp',
+              'objc++', 'obj-c++', 'obj_c++', 'objectivec++'
+      filenames '*.mm', '*.h'
+
+      mimetypes 'text/x-objective-c++', 'application/x-objective-c++'
+
+      prepend :statements do
+        rule %r/(\.)(class)/ do
+          groups(Operator, Name::Builtin::Pseudo)
+        end
+        rule %r/(@selector)(\()(class)(\))/ do
+          groups(Keyword, Punctuation, Name::Builtin::Pseudo, Punctuation)
+        end
+      end
+    end
+  end
+end

data/rouge-5.0.0/lib/rouge/lexers/ocaml/common.rb

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    # shared states with Reasonml and ReScript
+    class OCamlCommon < RegexLexer
+      def self.keywords
+        @keywords ||= Set.new %w(
+          as assert begin class constraint do done downto else end
+          exception external false for fun function functor if in
+          include inherit initializer lazy let module mutable new
+          nonrec object of open rec sig struct then to true try type
+          val virtual when while with
+        )
+      end
+
+      def self.word_operators
+        @word_operators ||= Set.new %w(and asr land lor lsl lxor mod or)
+      end
+
+      def self.primitives
+        @primitives ||= Set.new %w(unit int float bool string char list array)
+      end
+
+      @@operator = %r([;,_!$%&*+./:<=>?@^|~#-]+)
+      @@id = /[a-z_][\w']*/i
+      @@upper_id = /[A-Z][\w']*/
+
+      state :string do
+        rule %r/[^\\"]+/, Str::Double
+        mixin :escape_sequence
+        rule %r/\\\n/, Str::Double
+        rule %r/"/, Str::Double, :pop!
+      end
+
+      state :escape_sequence do
+        rule %r/\\[\\"'ntbr]/, Str::Escape
+        rule %r/\\\d{3}/, Str::Escape
+        rule %r/\\x\h{2}/, Str::Escape
+      end
+
+      state :dotted do
+        rule %r/\s+/m, Text
+        rule %r/[.]/, Punctuation
+        rule %r/#{@@upper_id}(?=\s*[.])/, Name::Namespace
+        rule @@upper_id, Name::Class, :pop!
+        rule @@id, Name, :pop!
+        rule %r/[({\[]/, Punctuation, :pop!
+      end
+    end
+  end
+end

data/rouge-5.0.0/lib/rouge/lexers/ocaml.rb

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+require_relative 'ocaml/common'
+
+module Rouge
+  module Lexers
+    class OCaml < OCamlCommon
+      title "OCaml"
+      desc 'Objective Caml (ocaml.org)'
+      tag 'ocaml'
+      filenames '*.ml', '*.mli', '*.mll', '*.mly'
+      mimetypes 'text/x-ocaml'
+
+      def self.keywords
+        @keywords ||= super + Set.new(%w(
+          match raise
+        ))
+      end
+
+      state :root do
+        rule %r/\s+/m, Text
+        rule %r/false|true|[(][)]|\[\]/, Name::Builtin::Pseudo
+        rule %r/#{@@upper_id}(?=\s*[.])/, Name::Namespace, :dotted
+        rule %r/`#{@@id}/, Name::Tag
+        rule @@upper_id, Name::Class
+        rule %r/[(][*](?![)])/, Comment, :comment
+        rule @@id do |m|
+          match = m[0]
+          if self.class.keywords.include? match
+            token Keyword
+          elsif self.class.word_operators.include? match
+            token Operator::Word
+          elsif self.class.primitives.include? match
+            token Keyword::Type
+          else
+            token Name
+          end
+        end
+
+        rule %r/[(){}\[\];]+/, Punctuation
+        rule @@operator, Operator
+
+        rule %r/-?\d[\d_]*(.[\d_]*)?(e[+-]?\d[\d_]*)/i, Num::Float
+        rule %r/0x\h[\h_]*/i, Num::Hex
+        rule %r/0o[0-7][0-7_]*/i, Num::Oct
+        rule %r/0b[01][01_]*/i, Num::Bin
+        rule %r/\d[\d_]*/, Num::Integer
+
+        rule %r/'(?:(\\[\\"'ntbr ])|(\\[0-9]{3})|(\\x\h{2}))'/, Str::Char
+        rule %r/'[.]'/, Str::Char
+        rule %r/'/, Keyword
+        rule %r/"/, Str::Double, :string
+        rule %r/[~?]#{@@id}/, Name::Variable
+      end
+
+      state :comment do
+        rule %r/[^(*)]+/, Comment
+        rule(/[(][*]/) { token Comment; push }
+        rule %r/[*][)]/, Comment, :pop!
+        rule %r/[(*)]/, Comment
+      end
+    end
+  end
+end

data/rouge-5.0.0/lib/rouge/lexers/ocl.rb

@@ -0,0 +1,84 @@
+module Rouge
+  module Lexers
+    class OCL < RegexLexer
+      title "OCL"
+      desc "OMG Object Constraint Language (omg.org/spec/OCL)"
+      tag 'ocl'
+      aliases 'OCL'
+      filenames '*.ocl'
+      mimetypes 'text/x-ocl'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          context pre post inv init body def derive if then else endif import
+          package endpackage let in
+        )
+      end
+
+      def self.keywords_type
+        @keywords_type ||= Set.new %w(
+          Boolean Integer UnlimitedNatural Real String OrderedSet Tuple Bag Set
+          Sequence OclInvalid OclVoid TupleType OclState Collection OclMessage
+        )
+      end
+
+      def self.builtins
+        @builtins ||= Set.new %w(
+          self null result true false invalid @pre
+          )
+      end
+
+      def self.operators
+        @operators ||= Set.new %w(
+          or xor and not implies
+        )
+      end
+
+      def self.functions
+        @functions ||= Set.new %w(
+          oclAsSet oclIsNew oclIsUndefined oclIsInvalid oclAsType oclIsTypeOf
+          oclIsKindOf oclInState oclType oclLocale hasReturned result
+          isSignalSent isOperationCallabs floor round max min toString div mod
+          size substring concat toInteger toReal toUpperCase toLowerCase
+          indexOf equalsIgnoreCase at characters toBoolean includes excludes
+          count includesAll excludesAll isEmpty notEmpty sum product
+          selectByKind selectByType asBag asSequence asOrderedSet asSet flatten
+          union intersection including excluding symmetricDifferencecount
+          append prepend insertAt subOrderedSet first last reverse subSequence
+          any closure collect collectNested exists forAll isUnique iterate one
+          reject select sortedBy allInstances average conformsTo
+        )
+      end
+
+      state :single_string do
+        rule %r/\\./, Str::Escape
+        rule %r/'/, Str::Single, :pop!
+        rule %r/[^\\']+/, Str::Single
+      end
+
+      state :root do
+        rule %r/\s+/m, Text
+        rule %r/--.*/, Comment::Single
+        rule %r/\d+/, Num::Integer
+        rule %r/'/, Str::Single, :single_string
+        rule %r([-|+*/<>=~!@#%&?^]), Operator
+        rule %r/[;:()\[\],.]/, Punctuation
+        rule %r/[a-zA-Z]\w*/ do |m|
+          if self.class.operators.include? m[0]
+            token Operator
+          elsif self.class.keywords_type.include? m[0]
+            token Keyword::Declaration
+          elsif self.class.keywords.include? m[0]
+            token Keyword
+          elsif self.class.builtins.include? m[0]
+            token Name::Builtin
+          elsif self.class.functions.include? m[0]
+            token Name::Function
+          else
+            token Name
+          end
+        end
+      end
+    end
+  end
+end