rouge 2.1.1 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 726f116a1b78032be65f6abef810b5b1db42a093
-  data.tar.gz: acb0e9e2ad10c72f5e455517f17b71382693016b
+  metadata.gz: 4a52694e10ac2f03c8d2eadd1379cd10d3218df7
+  data.tar.gz: e7962a37f67e9fa857c066879f265e04b61bd553
 SHA512:
-  metadata.gz: cb8b9f3139cc5d9539aa4b539a6c03f1b36630bc2483bac383cce749cff0f8b87565eeaa30ec74a0312098b77ae5e89824b063a89e36d1e53a986ad330a97e6f
-  data.tar.gz: 61a48f640f1594d76ff48efe7501a3c5c151d9703d130a6d25db3c318a882b494a0409b9df8103c32fed6fad6768e617d158b84dedfb0b64dbd07dceaf4456e8
+  metadata.gz: c55cc1e3ca7c1db144a7c4df78bbab3c8af73367006072ea2d579b9d3d9c5d31234721e5c0cf82ad84fe315c070e9689287a8a0e586df6a1a231a951934726f7
+  data.tar.gz: f6a5777bacb090afc87ef413ab4bb069e15bc7a25ef72450565ae2994eb31d24e4e8b0eb08ae5494fdb03cdb0172fc7902040ffa14646133f7ae6fdf6597021c

data/Gemfile

@@ -7,8 +7,6 @@ gem 'wrong'
 
 gem 'rubocop', '~> 0.49.1' if RUBY_VERSION >= '2.0.0'
 
-gem 'rake'
-
 # don't try to install redcarpet under jruby
 gem 'redcarpet', :platforms => :ruby
 

data/bin/rougify

@@ -4,7 +4,7 @@ require 'pathname'
 ROOT_DIR = Pathname.new(__FILE__).dirname.parent
 load ROOT_DIR.join('lib/rouge.rb')
 load ROOT_DIR.join('lib/rouge/cli.rb')
-Signal.trap('SIGPIPE', 'SYSTEM_DEFAULT')
+Signal.trap('PIPE', 'SYSTEM_DEFAULT') if Signal.list.include? 'PIPE'
 
 begin
   Rouge::CLI.parse(ARGV).run

data/lib/rouge/cli.rb

@@ -273,6 +273,7 @@ module Rouge
         when 'html-pygments' then Formatters::HTMLPygments.new(Formatters::HTML.new, opts[:css_class])
         when 'html-inline' then Formatters::HTMLInline.new(theme)
         when 'html-table' then Formatters::HTMLTable.new(Formatters::HTML.new)
+        when 'null', 'raw', 'tokens' then Formatters::Null.new
         else
           error! "unknown formatter preset #{opts[:formatter]}"
         end

data/lib/rouge/demos/gherkin

@@ -1,7 +1,7 @@
 # language: en
 Feature: Addition
   In order to avoid silly mistakes
-  As a math idiot
+  As someone who has trouble with mental math
   I want to be told the sum of two numbers
 
   Scenario Outline: Add two numbers

data/lib/rouge/demos/nix

@@ -0,0 +1,19 @@
+# See https://nixos.org/nix/manual/#sec-expression-syntax
+{ stdenv, fetchurl, perl }: # 1
+
+stdenv.mkDerivation { # 2
+  name = "hello-2.1.1"; # 3
+  builder = ./builder.sh; # 4
+  meta = rec {
+    name = "rouge";
+    version = "${name}-2.1.1";
+    number = 55 + 12;
+    isSmaller = number < 42;
+    bool = true;
+  };
+  src = fetchurl { # 5
+    url = ftp://ftp.nluug.nl/pub/gnu/hello/hello-2.1.1.tar.gz; # path
+    md5 = "70c9ccf9fac07f762c24f2df2290784d";
+  };
+  inherit perl; # 6
+}

data/lib/rouge/formatter.rb

@@ -21,8 +21,8 @@ module Rouge
     end
 
     # Format a token stream.  Delegates to {#format}.
-    def self.format(tokens, opts={}, &b)
-      new(opts).format(tokens, &b)
+    def self.format(tokens, *a, &b)
+      new(*a).format(tokens, &b)
     end
 
     def initialize(opts={})

data/lib/rouge/formatters/null.rb

@@ -11,7 +11,7 @@ module Rouge
 
       def stream(tokens, &b)
         tokens.each do |tok, val|
-          yield "#{tok} #{val.inspect}\n"
+          yield "#{tok.qualname} #{val.inspect}\n"
         end
       end
     end

data/lib/rouge/formatters/terminal256.rb

@@ -4,13 +4,21 @@ module Rouge
   module Formatters
     # A formatter for 256-color terminals
     class Terminal256 < Formatter
+      tag 'terminal256'
+
       # @private
       attr_reader :theme
 
-      # @argument theme
+      # @param [Hash,Rouge::Theme] theme
       #   the theme to render with.
-      def initialize(theme=nil)
-        @theme = theme || Themes::ThankfulEyes
+      def initialize(theme = Themes::ThankfulEyes.new)
+        if theme.is_a?(Rouge::Theme)
+          @theme = theme
+        elsif theme.is_a?(Hash)
+          @theme = theme[:theme] || Themes::ThankfulEyes.new
+        else
+          raise ArgumentError, "invalid theme: #{theme.inspect}"
+        end
       end
 
       def stream(tokens, &b)

data/lib/rouge/lexers/fortran.rb

@@ -19,27 +19,30 @@ module Rouge
       exponent = /[ED][+-]?\d+/i
 
       def self.keywords
-        # Fortran allows to omit whitespace between certain keywords...
+        # Special rules for two-word keywords are defined further down.
+        # Note: Fortran allows to omit whitespace between certain keywords.
         @keywords ||= Set.new %w(
-          abstract all allocatable allocate assign assignment asynchronous
-          backspace bind block blockdata close common concurrent contiguous call
-          case class codimension contains continue cycle data deallocate
-          deferred dimension do elemental else elseif elsewhere end endblock
-          endblockdata enddo endenum endfile endforall endfunction endif
-          endinterface endmodule endprogram endselect endsubmodule endsubroutine
-          endtype endwhere endwhile entry enum enumerator equivalence error exit
-          external final flush forall format function generic go goto if
-          implicit import in include inout inquire intent interface intrinsic is
-          module namelist non_overridable none nopass nullify only open operator
-          optional out parameter pass pause pointer print private procedure
-          program protected public pure read recursive result return rewind save
-          select selectcase sequence stop submodule subroutine target then to
-          type use value volatile wait where while write
+          abstract allocatable allocate assign assignment associate asynchronous
+          backspace bind block blockdata call case class close codimension
+          common concurrent contains contiguous continue critical cycle data
+          deallocate deferred dimension do elemental else elseif elsewhere end
+          endassociate endblock endblockdata enddo endenum endfile endforall
+          endfunction endif endinterface endmodule endprogram endselect
+          endsubmodule endsubroutine endtype endwhere endwhile entry enum
+          enumerator equivalence exit extends external final flush forall format
+          function generic goto if implicit import in include inout inquire
+          intent interface intrinsic is lock module namelist non_overridable
+          none nopass nullify only open operator optional out parameter pass
+          pause pointer print private procedure program protected public pure
+          read recursive result return rewind save select selectcase sequence
+          stop submodule subroutine target then type unlock use value volatile
+          wait where while write
         )
       end
 
       def self.types
-        # There is a separate rule for "double precision" (two words) below
+        # A special rule for the two-word version "double precision" is
+        # defined further down.
         @types ||= Set.new %w(
           character complex doubleprecision integer logical real
         )
@@ -48,16 +51,16 @@ module Rouge
       def self.intrinsics
         @intrinsics ||= Set.new %w(
           abs achar acos acosh adjustl adjustr aimag aint all allocated anint
-          any asin asinh associated atan atan2 atanh bessel_j0 bessel_j1
-          bessel_jn bessel_y0 bessel_y1 bessel_yn bge bgt bit_size ble blt btest
-          c_associated c_f_pointer c_f_procpointer c_funloc c_loc c_sizeof
-          ceiling char cmplx command_argument_count compiler_options
-          compiler_version conjg cos cosh count cpu_time cshift date_and_time
-          dble digits dim dot_product dprod dshiftl dshiftr eoshift epsilon erf
-          erfc_scaled erfc execute_command_line exp exponent extends_type_of
-          findloc floor fraction gamma get_command_argument get_command
-          get_environment_variable huge hypot iachar iall iand iany ibclr ibits
-          ibset ichar ieee_class ieee_copy_sign ieee_get_flag
+          any asin asinh associated atan atan2 atanh atomic_define atomic_ref
+          bessel_j0 bessel_j1 bessel_jn bessel_y0 bessel_y1 bessel_yn bge bgt
+          bit_size ble blt btest c_associated c_f_pointer c_f_procpointer
+          c_funloc c_loc c_sizeof ceiling char cmplx command_argument_count
+          compiler_options compiler_version conjg cos cosh count cpu_time cshift
+          date_and_time dble digits dim dot_product dprod dshiftl dshiftr
+          eoshift epsilon erf erfc_scaled erfc execute_command_line exp exponent
+          extends_type_of findloc floor fraction gamma get_command_argument
+          get_command get_environment_variable huge hypot iachar iall iand iany
+          ibclr ibits ibset ichar ieee_class ieee_copy_sign ieee_get_flag
           ieee_get_halting_mode ieee_get_rounding_mode ieee_get_status
           ieee_get_underflow_mode ieee_is_finite ieee_is_nan ieee_is_normal
           ieee_logb ieee_next_after ieee_rem ieee_rint ieee_scalb
@@ -124,9 +127,12 @@ module Rouge
         rule %r{\*\*|//|==|/=|<=|>=|=>|[-+*/<>=%]}, Operator
         rule /\.(?:EQ|NE|LT|LE|GT|GE|NOT|AND|OR|EQV|NEQV|[A-Z]+)\./i, Operator::Word
 
-        # To make sure "double precision" written as two words is highlighted
-        # properly. "doubleprecision" is covered by a different rule.
+        # Special rules for two-word keywords and types.
+        # Note: "doubleprecision" is covered by the normal keyword rule.
         rule /double\s+precision\b/i, Keyword::Type
+        rule /go\s+to\b/i, Keyword
+        rule /sync\s+(all|images|memory)\b/i, Keyword
+        rule /error\s+stop\b/i, Keyword
 
         rule /#{name}/m do |m|
           match = m[0].downcase

data/lib/rouge/lexers/igorpro.rb

@@ -19,6 +19,7 @@ module Rouge
           break return continue
           for endfor do while
           case default
+	  try catch endtry
           abortonrte
         )
       end
@@ -247,12 +248,11 @@ module Rouge
       end
 
       def self.object_name
-        /[a-z][a-z0-9_]*\b/i
+        /\b[a-z][a-z0-9_\.]*?\b/i
       end
 
       object = self.object_name
-      whitespace  = /[\s\r]+/
-      noLineBreak = /[ \t]+/
+      noLineBreak = /(?:[ \t]|(?:\\\s*[\r\n]))+/
       operator = %r([\#$~!%^&*+=\|?:<>/-])
       punctuation = /[{}()\[\],.;]/
       number_float= /0x[a-f0-9]+/i
@@ -262,7 +262,7 @@ module Rouge
       state :root do
         rule %r(//), Comment, :comments
 
-        rule /\b#{object}/ do |m|
+        rule /#{object}/ do |m|
           if m[0].downcase =~ /function/
             token Keyword::Declaration
             push :parse_function
@@ -281,8 +281,8 @@ module Rouge
           elsif self.class.hdf5Operation.include? m[0].downcase
             token Keyword::Reserved
             push :operationFlags
-          elsif m[0].downcase =~ /(v|s|w)_[a-z]+[a-z0-9]*/
-            token Name::Builtin
+          elsif m[0].downcase =~ /\b(v|s|w)_[a-z]+[a-z0-9]*/
+            token Name::Constant
           else
             token Name
           end
@@ -293,6 +293,7 @@ module Rouge
 
         mixin :characters
         mixin :numbers
+        mixin :whitespace
       end
 
       state :preprocessor do
@@ -310,7 +311,7 @@ module Rouge
 
       state :assignment do
         mixin :whitespace
-        rule /\"/, Punctuation, :string1
+        rule /\"/, Literal::String::Double, :string1 #punctuation for string
         mixin :string2
         rule /#{number_float}/, Literal::Number::Float, :pop!
         rule /#{number_int}/, Literal::Number::Integer, :pop!
@@ -322,11 +323,11 @@ module Rouge
       state :parse_variables do
         mixin :whitespace
         rule /[=]/, Punctuation, :assignment
-        rule %r([/][a-z]+)i, Keyword::Pseudo, :parse_variables
         rule object, Name::Variable
         rule /[\[\]]/, Punctuation # optional variables in functions
         rule /[,]/, Punctuation, :parse_variables
         rule /\)/, Punctuation, :pop! # end of function
+        rule %r([/][a-z]+)i, Keyword::Pseudo, :parse_variables
         rule(//) { pop! }
       end
 
@@ -367,7 +368,7 @@ module Rouge
         rule /\s/, Text
         rule /#{operator}/, Operator
         rule /#{punctuation}/, Punctuation
-        rule /\"/, Punctuation, :string1
+        rule /\"/, Literal::String::Double, :string1 #punctuation for string
         mixin :string2
       end
 
@@ -387,7 +388,7 @@ module Rouge
         rule /\\\"/, Literal::String::Escape
         rule /\\/, Literal::String::Escape
         rule /[^"]/, Literal::String
-        rule /\"/, Punctuation, :pop!
+        rule /\"/, Literal::String::Double, :pop! #punctuation for string
       end
 
       state :string2 do

data/lib/rouge/lexers/javascript.rb

@@ -198,12 +198,24 @@ module Rouge
         rule /0o[0-7][0-7_]*/i, Num::Oct
         rule /0b[01][01_]*/i, Num::Bin
         rule /[0-9]+/, Num::Integer
-    
-        rule /"(\\[\\"]|[^"])*"/, Str::Double
-        rule /'(\\[\\']|[^'])*'/, Str::Single
+
+        rule /"/, Str::Double, :dq
+        rule /'/, Str::Single, :sq
         rule /:/, Punctuation
       end
 
+      state :dq do
+        rule /[^\\"]+/, Str::Double
+        rule /\\"/, Str::Escape
+        rule /"/, Str::Double, :pop!
+      end
+
+      state :sq do
+        rule /[^\\']+/, Str::Single
+        rule /\\'/, Str::Escape
+        rule /'/, Str::Single, :pop!
+      end
+
       # braced parts that aren't object literals
       state :statement do
         rule /case\b/ do

data/lib/rouge/lexers/kotlin.rb

@@ -41,7 +41,7 @@ module Rouge
         rule %r'"(\\\\|\\"|[^"\n])*["\n]'m, Str
         rule %r"'\\.'|'[^\\]'", Str::Char
         rule %r"[0-9](\.[0-9]+)?([eE][+-][0-9]+)?[flFL]?|0[xX][0-9a-fA-F]+[Ll]?", Num
-        rule %r'(class)(\s+)(object)' do
+        rule %r'(companion)(\s+)(object)' do
           groups Keyword, Text, Keyword
         end
         rule %r'(class|data\s+class|interface|object)(\s+)' do

data/lib/rouge/lexers/nix.rb

@@ -0,0 +1,205 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Nix < RegexLexer
+      title 'Nix'
+      desc 'The Nix expression language (https://nixos.org/nix/manual/#ch-expression-language)'
+      tag 'nix'
+      aliases 'nixos'
+      filenames '*.nix'
+
+      state :whitespaces do
+        rule /^\s*\n\s*$/m, Text
+        rule /\s+/, Text
+      end
+
+      state :comment do
+        rule /#.*$/, Comment
+        rule /\/\*/, Comment, :multiline_comment
+      end
+
+      state :multiline_comment do
+        rule /\*\//, Comment, :pop!
+        rule /./, Comment
+      end
+
+      state :number do
+        rule /[0-9]/, Num::Integer
+      end
+
+      state :null do
+        rule /(null)/, Keyword::Constant
+      end
+
+      state :boolean do
+        rule /(true|false)/, Keyword::Constant
+      end
+
+      state :binding do
+        rule /[a-zA-Z_][a-zA-Z0-9-]*/, Name::Variable
+      end
+
+      state :path do
+        word = "[a-zA-Z0-9\._-]+"
+        section = "(\/#{word})"
+        prefix = "[a-z\+]+:\/\/"
+        root = /#{section}+/.source
+        tilde = /~#{section}+/.source
+        basic = /#{word}(\/#{word})+/.source
+        url = /#{prefix}(\/?#{basic})/.source
+        rule /(#{root}|#{tilde}|#{basic}|#{url})/, Str::Other
+      end
+
+      state :string do
+        rule /"/, Str::Double, :string_double_quoted
+        rule /''/, Str::Double, :string_indented
+      end
+
+      state :string_content do
+        rule /\${/, Str::Interpol, :string_interpolated_arg
+        mixin :escaped_sequence
+      end
+
+      state :escaped_sequence do
+        rule /\\./, Str::Escape
+      end
+
+      state :string_interpolated_arg do
+        mixin :expression
+        rule /}/, Str::Interpol, :pop!
+      end
+
+      state :string_indented do
+        mixin :string_content
+        rule /''/, Str::Double, :pop!
+        rule /./, Str::Double
+      end
+
+      state :string_double_quoted do
+        mixin :string_content
+        rule /"/, Str::Double, :pop!
+        rule /./, Str::Double
+      end
+
+      state :operator do
+        rule /(\.|\?|\+\+|\+|!=|!|\/\/|\=\=|&&|\|\||->|\/|\*|-|<|>|<=|=>)/, Operator
+      end
+
+      state :assignment do
+        rule /(=)/, Operator
+        rule /(@)/, Operator
+      end
+
+      state :accessor do
+        rule /(\$)/, Punctuation
+      end
+
+      state :delimiter do
+        rule /(;|,|:)/, Punctuation
+      end
+
+      state :atom_content do
+        mixin :expression
+        rule /\)/, Punctuation, :pop!
+      end
+
+      state :atom do
+        rule /\(/, Punctuation, :atom_content
+      end
+
+      state :list do
+        rule /\[/, Punctuation, :list_content
+      end
+
+      state :list_content do
+        rule /\]/, Punctuation, :pop!
+        mixin :expression
+      end
+
+      state :set do
+        rule /{/, Punctuation, :set_content
+      end
+
+      state :set_content do
+        rule /}/, Punctuation, :pop!
+        mixin :expression
+      end
+      
+      state :expression do
+        mixin :ignore
+        mixin :comment
+        mixin :boolean
+        mixin :null
+        mixin :number
+        mixin :path
+        mixin :string
+        mixin :keywords
+        mixin :operator
+        mixin :accessor
+        mixin :assignment
+        mixin :delimiter
+        mixin :binding
+        mixin :atom
+        mixin :set
+        mixin :list
+      end
+
+      state :keywords do
+        mixin :keywords_namespace
+        mixin :keywords_declaration
+        mixin :keywords_conditional
+        mixin :keywords_reserved
+        mixin :keywords_builtin
+      end
+
+      state :keywords_namespace do
+        keywords = %w(with in inherit)
+        rule /(?:#{keywords.join('|')})\b/, Keyword::Namespace
+      end
+
+      state :keywords_declaration do
+        keywords = %w(let)
+        rule /(?:#{keywords.join('|')})\b/, Keyword::Declaration
+      end
+
+      state :keywords_conditional do
+        keywords = %w(if then else)
+        rule /(?:#{keywords.join('|')})\b/, Keyword
+      end
+
+      state :keywords_reserved do
+        keywords = %w(rec assert map)
+        rule /(?:#{keywords.join('|')})\b/, Keyword::Reserved
+      end
+
+      state :keywords_builtin do
+        keywords = %w(
+          abort
+          baseNameOf
+          builtins
+          derivation
+          fetchTarball
+          import
+          isNull
+          removeAttrs
+          throw
+          toString
+        )
+        rule /(?:#{keywords.join('|')})\b/, Keyword::Reserved
+      end
+
+      state :ignore do
+        mixin :whitespaces
+      end
+
+      state :root do
+        mixin :ignore
+        mixin :expression
+      end
+
+      start do
+      end
+    end
+  end
+end

data/lib/rouge/lexers/q.rb

@@ -94,8 +94,11 @@ module Rouge
         rule(%r{'|\/:|\\:|':|\\|\/|0:|1:|2:}, Operator)
 
         ## numbers
-        rule(/(?:\d+(?:\.\d*)?|\.\d+)(?:e[+\-]?\d+|\d+\.\d*|\.\d+)?[ef]?/, Num::Float)
-        rule(/[01]+b?/, Num)
+        rule(/(\d+[.]\d*|[.]\d+)(e[+-]?\d+)?[ef]?/, Num::Float)
+        rule(/\d+e[+-]?\d+[ef]?/, Num::Float)
+        rule(/\d+[ef]/, Num::Float)
+        rule(/0x[0-9a-f]+/i, Num::Hex)
+        rule(/[01]+b/, Num::Bin)
         rule(/[0-9]+[hij]?/, Num::Integer)
         ## symbols and paths
         rule(%r{(`:[:a-z0-9._\/]*|`(?:[a-z0-9.][:a-z0-9._]*)?)}i, Str::Symbol)

data/lib/rouge/text_analyzer.rb

@@ -15,6 +15,7 @@ module Rouge
     # This normalizes things so that `text.shebang?('bash')` will detect
     # `#!/bash`, '#!/bin/bash', '#!/usr/bin/env bash', and '#!/bin/bash -x'
     def shebang?(match)
+      return false unless shebang
       match = /\b#{match}(\s|$)/
       match === shebang
     end

data/lib/rouge/version.rb

@@ -2,6 +2,6 @@
 
 module Rouge
   def self.version
-    "2.1.1"
+    "2.2.0"
   end
 end

data/rouge.gemspec

@@ -14,5 +14,8 @@ Gem::Specification.new do |s|
   s.rubyforge_project = "rouge"
   s.files = Dir['Gemfile', 'LICENSE', 'rouge.gemspec', 'lib/**/*.rb', 'lib/**/*.yml', 'bin/rougify', 'lib/rouge/demos/*']
   s.executables = %w(rougify)
-  s.license = 'MIT, 2-clause BSD'
+  s.licenses = ['MIT', 'BSD-2-Clause']
+
+  s.add_development_dependency "bundler", "~> 1.10"
+  s.add_development_dependency "rake", "~> 12.0"
 end

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: rouge
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.2.0
 platform: ruby
 authors:
 - Jeanine Adkisson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-22 00:00:00.000000000 Z
-dependencies: []
+date: 2017-08-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
 description: Rouge aims to a be a simple, easy-to-extend drop-in replacement for pygments.
 email:
 - jneen@jneen.net
@@ -99,6 +127,7 @@ files:
 - lib/rouge/demos/nasm
 - lib/rouge/demos/nginx
 - lib/rouge/demos/nim
+- lib/rouge/demos/nix
 - lib/rouge/demos/objective_c
 - lib/rouge/demos/ocaml
 - lib/rouge/demos/pascal
@@ -248,6 +277,7 @@ files:
 - lib/rouge/lexers/nasm.rb
 - lib/rouge/lexers/nginx.rb
 - lib/rouge/lexers/nim.rb
+- lib/rouge/lexers/nix.rb
 - lib/rouge/lexers/objective_c.rb
 - lib/rouge/lexers/ocaml.rb
 - lib/rouge/lexers/pascal.rb
@@ -327,7 +357,8 @@ files:
 - rouge.gemspec
 homepage: http://rouge.jneen.net/
 licenses:
-- MIT, 2-clause BSD
+- MIT
+- BSD-2-Clause
 metadata: {}
 post_install_message: 
 rdoc_options: []