licensee 2.0.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9b45a6b8c2dada9497081deeb9647043ee37c0a8
-  data.tar.gz: bcbf1d51786773643525e8683fd98ee13b0c9971
+  metadata.gz: 839782ad5361d8938500dd5938eb33e38a821d9a
+  data.tar.gz: a688eb2acdf6a1da457cdcf4037a346e4b20691c
 SHA512:
-  metadata.gz: fc8fdb2c8c0576470179896e7a8c2fd5c63cd641aa1fcf2a5699d56a7fbb6972ea7a9a4a59edde88071b38dd9b5b1df62796f0d14acfa18a20fca953198c1ea0
-  data.tar.gz: 41e76bb395c9bf949cbf6a78da120854c3512d12db9628f3e814ac0471343f92847231813059481a83fd793fddbcbce6c315ee26b55fe30428499a4ea6cd1671
+  metadata.gz: 61151787e52a75c131b53b6ffdc38e8e8c7140546837e39bc3586bf87928d43b12505ee5f983b853520c6f65d1c742c0b3c381200df95b824a8a957bb031576a
+  data.tar.gz: 9bfe7533e62e998eb1406c663ba93bf2db81f85a92d274f1efb5f2d389f6e6e029e88b64ba94955d4dc322545254506287734d767b37ae70b40840238083cf7d

data/README.md

@@ -12,9 +12,13 @@
 
 ## The solution
 
-Licensee automates the process of reading `LICENSE` files and compares their contents to known licenses using a fancy math thing called the [Rabin-Karp rolling-hashes](https://en.wikipedia.org/wiki/Rabin%E2%80%93Karp_algorithm), the same mechanism Git itself uses to compute changes between files. In fact, Licensee just uses Git.
+Licensee automates the process of reading `LICENSE` files and compares their contents to known licenses using a several strategies (which we call "Matchers":
 
-By calculating the percent changed from the known license, you can tell, e.g., that a given license is 98% similar to the MIT license, that 2% likely representing the copyright line being properly adapted to the project.
+First, we look to see if the license is an exact match. Licenses like GPL don't have a copyright notice that needs to be changed in the license itself, so if we strip away whitespace, we might get lucky, and direct string comparison is cheap.
+
+Next, we look to Git's internal change calculation method, which is fast, but is done on a line-by-line basis, so if the license is wrapped differently, or has extra words inserted, it's not going to match the license.
+
+Finally, if we still can't match the license, we use a fancy math thing called the [Levenshtein distance algorthm](https://en.wikipedia.org/wiki/Levenshtein_distance), which while slow, is really good at calculating the similarity between two a known license and an unknown license. By calculating the percent changed from the known license, you can tell, e.g., that a given license is 98% similar to the MIT license, that 2% likely representing the copyright line being properly adapted to the project.
 
 Licensee will even diff the distributed license with the original, so you can see exactly what, if anything's been changed.
 
@@ -41,13 +45,6 @@ license.meta["description"]
 
 license.meta["permitted"]
 => ["commercial-use","modifications","distribution","sublicense","private-use"]
-
-# Getting all matches
-Licensee.matches "/path/to/a/project"
-=> [#<Licensee::License name="MIT" match=0.9842154131847726>,
- #<Licensee::License name="unlicense" match=0.4326833797585887>,
- ...
- #<Licensee::License name="no-license" match=0.0232126276694522>]
 ```
 
 ## Diffing
@@ -72,6 +69,7 @@ You'll get an output that looks like:
 ```
 License: MIT
 Confidence: 98.42%
+Matcher: Licensee::GitMatcher
 ```
 
 ## What it looks at

data/bin/licensee

@@ -6,6 +6,7 @@ license = Licensee::Project.new(Dir.pwd).license_file
 if license
   puts "License: #{license.match ? license.match.meta['title'] : 'no license'}"
   puts "Confidence: #{license.confidence}%"
+  puts "Method: #{license.matcher.class}"
 else
   puts "Unknown"
 end

data/lib/licensee.rb

@@ -1,19 +1,42 @@
 require 'yaml'
 require 'rugged'
+require 'levenshtein'
 
 require_relative "licensee/license"
 require_relative "licensee/licenses"
 require_relative "licensee/license_file"
 require_relative "licensee/project"
+require_relative "licensee/matcher"
+require_relative "licensee/matchers/exact_matcher"
+require_relative "licensee/matchers/git_matcher"
+require_relative "licensee/matchers/levenshtein_matcher"
 
 class Licensee
+
+  # Over watch percent is a match considered a match
   CONFIDENCE_THRESHOLD = 90
 
-  def self.licenses
-    Licensee::Licenses.list
-  end
+  class << self
+
+    # Returns an array of Licensee::License instances
+    def licenses
+      @licenses ||= Licensee::Licenses.list
+    end
+
+    # Returns the license for a given git repo
+    def license(path)
+      Licensee::Project.new(path).license
+    end
+
+    # Diffs the project license and the known license
+    def diff(path)
+      Licensee::Project.new(path).license_file.diff
+    end
 
-  def self.license(path)
-    Licensee::Project.new(path).license
+    # Array of matchers to use, in order of preference
+    # The order should be decending order of anticipated speed to match
+    def matchers
+      [Licensee::ExactMatcher, Licensee::GitMatcher, Licensee::LevenshteinMatcher]
+    end
   end
 end

data/lib/licensee/license.rb

@@ -6,34 +6,36 @@ class Licensee
       @name=name.downcase
     end
 
+    # Path to vendored license file on disk
     def path
       @path ||= File.expand_path "#{@name}.txt", Licensee::Licenses.base
     end
 
+    # Raw content of license file, including YAML front matter
     def content
       @content ||= File.open(path).read
     end
 
-    def parts
-      @parts ||= content.match(/^(---\n.*\n---)?(.*)/m).to_a
-    end
-
+    # License metadata from YAML front matter
     def meta
       @meta ||= front_matter = YAML.load(parts[1]) if parts[1]
     rescue
       nil
     end
 
-    def length
-      @length ||= body.length
-    end
-
+    # The license body (e.g., contents - frontmatter)
     def body
       @body ||= parts[2]
     end
     alias_method :to_s, :body
     alias_method :text, :body
 
+    # License body with all whitespace replaced with a single space
+    def body_normalized
+      @content_normalized ||= body.downcase.gsub(/\s+/, " ").strip
+    end
+
+    # Git-computed hash signature for the license file
     def hashsig
       @hashsig ||= Rugged::Blob::HashSignature.new(
         body, Rugged::Blob::HashSignature::WHITESPACE_SMART)
@@ -42,5 +44,11 @@ class Licensee
     def inspect
       "#<Licensee::License name=\"#{name}\">"
     end
+
+    private
+
+    def parts
+      @parts ||= content.match(/^(---\n.*\n---)?(.*)/m).to_a
+    end
   end
 end

data/lib/licensee/license_file.rb

@@ -7,43 +7,39 @@ class Licensee
       blob.hashsig(Rugged::Blob::HashSignature::WHITESPACE_SMART)
     end
 
-    def contents
-      @contents ||= blob.content
+    # Raw file contents
+    def content
+      @contents ||= begin
+        blob.content
+      end
     end
-    alias_method :to_s, :contents
-    alias_method :content, :contents
+    alias_method :to_s, :content
+    alias_method :contents, :content
 
-    def length
-      @length ||= blob.size
+    # File content with all whitespace replaced with a single space
+    def content_normalized
+      @content_normalized ||= content.downcase.gsub(/\s+/, " ").strip
     end
 
-    def matches
-      @matches ||= Licensee::Licenses.list.map { |l| [l, calculate_similarity(l)] }
+    # Comptutes a diff between known license and project license
+    def diff(options={})
+      options = options.merge(:reverse => true)
+      blob.diff(match.body, options).to_s if match
     end
 
-    def match_info
-      @match_info ||= matches.max_by { |license, similarity| similarity }
+    # Determines which matching strategy to use, returns an instane of that matcher
+    def matcher
+      @matcher ||= Licensee.matchers.map { |m| m.new(self) }.find { |m| m.match }
     end
 
+    # Returns an Licensee::License instance of the matches license
     def match
-      match_info ? match_info[0] : nil
+      @match ||= matcher.match if matcher
     end
 
+    # Returns the percent confident with the match
     def confidence
-      match_info ? match_info[1] : nil
-    end
-    alias_method :similarity, :confidence
-
-    def diff(options={})
-      options = options.merge(:reverse => true)
-      blob.diff(match.body, options).to_s if match
-    end
-
-    private
-
-    # Pulled out for easier testing
-    def calculate_similarity(other)
-      blob.similarity(other.hashsig)
+      @condience ||= matcher.confidence if matcher
     end
   end
 end

data/lib/licensee/licenses.rb

@@ -1,15 +1,8 @@
 class Licensee
   class Licenses
     class << self
-      def names
-        @names ||= begin
-          names = Dir.entries(base)
-          names.map! { |l| File.basename(l, ".txt").downcase }
-          names.reject! { |l| l =~ /^\./ || l.nil? }
-          names
-        end
-      end
 
+      # Returns an array of Licensee::License instances
       def list
         @licenses ||= begin
           licenses = []
@@ -18,14 +11,28 @@ class Licensee
         end
       end
 
+      # Given a license name, attempt to return a matching Licensee::License instance
+      def find(name)
+        list.find { |l| l.name.downcase == name.downcase }
+      end
+
+      # Path to vendored licenses
       def base
         @base ||= File.expand_path "../../vendor/choosealicense.com/_licenses", File.dirname(__FILE__)
       end
 
-      def find(name)
-        name = name.downcase
-        list.find { |l| l.name.downcase == name }
+      private
+
+      # Returns a list of potential license names, as vendored
+      def names
+        @names ||= begin
+          names = Dir.entries(base)
+          names.map! { |l| File.basename(l, ".txt").downcase }
+          names.reject! { |l| l =~ /^\./ || l.nil? }
+          names
+        end
       end
+
     end
   end
 end

data/lib/licensee/matcher.rb

@@ -0,0 +1,28 @@
+# Abstract class to describe different matching strategies
+# Must respond to:
+#   - match
+#   - confidence
+#
+# Can assume file will be a Licensee::LicenseFile instance
+class Licensee
+  class Matcher
+    attr_reader :file
+
+    def self.match(file)
+      self.new(file).match
+    end
+
+    def initialize(file)
+      @file = file
+    end
+
+    def match
+      nil
+    end
+
+    def confidence
+      0
+    end
+    alias_method :similarity, :confidence
+  end
+end

data/lib/licensee/matchers/exact_matcher.rb

@@ -0,0 +1,11 @@
+class Licensee
+  class ExactMatcher < Matcher
+    def match
+      Licensee.licenses.find { |l| l.body_normalized == file.content_normalized }
+    end
+
+    def confidence
+      100
+    end
+  end
+end

data/lib/licensee/matchers/git_matcher.rb

@@ -0,0 +1,30 @@
+class Licensee
+  class GitMatcher < Matcher
+
+    def match
+      match_info[0] unless match_info.nil?
+    end
+
+    def confidence
+      match_info[1] unless match_info.nil?
+    end
+
+    private
+
+    def matches
+      @matches ||= Licensee.licenses.map { |l| [l, similarity(l)] }.select { |l,sim| sim > 0 }
+    end
+
+    def similarity(other)
+      file.blob.similarity(other.hashsig)
+    end
+
+    # Pulled out for easier testing
+    def match_info
+      @match_info ||= begin
+        match = matches.max_by { |license, similarity| similarity }
+        match if match && match[1] > Licensee::CONFIDENCE_THRESHOLD
+      end
+    end
+  end
+end

data/lib/licensee/matchers/levenshtein_matcher.rb

@@ -0,0 +1,55 @@
+class Licensee
+  class LevenshteinMatcher < Matcher
+
+    # Return the first potential license that is more similar than the confidence threshold
+    def match
+      @match ||= potential_licenses.find do |license|
+        similarity(license) >= Licensee::CONFIDENCE_THRESHOLD
+      end
+    end
+
+    # Sort all licenses, in decending order, by difference in length to the file
+    # Difference in lengths cannot exceed the file's length * the confidence threshold / 100
+    def potential_licenses
+      @potential_licenses ||= begin
+        Licensee.licenses.select { |license| length_delta(license) <= max_delta }.sort_by { |l| length_delta(l) }
+      end
+    end
+
+    # Calculate the difference between the file length and a given license's length
+    def length_delta(license)
+      (file_length - license.body_normalized.length).abs
+    end
+
+    # Maximum possible difference between file length and license length
+    # for a license to be a potential license to be matched
+    def max_delta
+      @max_delta ||= (file_length * (Licensee::CONFIDENCE_THRESHOLD.to_f / 100.to_f ))
+    end
+
+    # Confidence that the matched license is a match
+    def confidence
+      @confidence ||= match ? similarity(match) : 0
+    end
+
+    private
+
+    # Length of the file, normalized to strip whitespace
+    def file_length
+      @file_length ||= file.content_normalized.length.to_f
+    end
+
+    # Calculate percent changed between file and potential license
+    def similarity(license)
+      100 * (file_length - distance(license)) / file_length
+    end
+
+    # Calculate the levenshtein distance between file and license
+    # Note: We used content/body normalized because white space and capitalization
+    # isn't legally significant in this context. Fewer characters lets levenshtein
+    # work faster. As long as they both undergo the same transformation, should match.
+    def distance(license)
+      Levenshtein.distance(license.body_normalized, file.content_normalized).to_f
+    end
+  end
+end

data/lib/licensee/project.rb

@@ -2,7 +2,8 @@ class Licensee
   class Project
     attr_reader :repository
 
-    VALID_FILENAMES = %w[
+    # Array of file names to look for potential license files, in order
+    LICENSE_FILENAMES = %w[
       LICENSE
       LICENSE.txt
       LICENSE.md
@@ -10,6 +11,10 @@ class Licensee
       COPYING
     ]
 
+    # Initializes a new project
+    #
+    # path_or_repo path to git repo or Rugged::Repository instance
+    # revsion - revision ref, if any
     def initialize(path_or_repo, revision = nil)
       if path_or_repo.kind_of? Rugged::Repository
         @repository = path_or_repo
@@ -20,22 +25,20 @@ class Licensee
       @revision = revision
     end
 
+    # Detects the license file, if any
+    # Returns a Licensee::LicenseFile instance
     def license_file
       return @license_file if defined? @license_file
 
       commit = @revision ? @repository.lookup(@revision) : @repository.last_commit
-      license_blob = commit.tree.each_blob { |blob| break blob if VALID_FILENAMES.include? blob[:name] }
-
+      license_blob = commit.tree.each_blob { |blob| break blob if LICENSE_FILENAMES.include? blob[:name] }
 
       @license_file = if license_blob
         LicenseFile.new(@repository.lookup(license_blob[:oid]))
       end
     end
 
-    def matches
-      @matches ||= license_file.matches if license_file
-    end
-
+    # Returns the matching Licensee::License instance if a license can be detected
     def license
       @license ||= license_file.match if license_file
     end

data/lib/licensee/version.rb

@@ -1,3 +1,3 @@
 class Licensee
-  VERSION = "2.0.0"
+  VERSION = "3.0.0"
 end

data/test/functions.rb

@@ -39,23 +39,32 @@ class FakeBlob
 end
 
 def chaos_monkey(string)
-  lines = string.each_line.to_a
-
-  Random.rand(5).times do
-    lines[Random.rand(lines.size)] = SecureRandom.base64(Random.rand(80)) + "\n"
+  Random.rand(7).times do
+    string[Random.rand(string.length)] = SecureRandom.base64(Random.rand(10))
   end
-
-  lines.join('')
+  string
 end
 
-def verify_license_file(license, chaos = false)
+def verify_license_file(license, chaos = false, wrap=false)
   expected = File.basename(license, ".txt")
 
   text = license_from_path(license)
-  blob = FakeBlob.new(chaos ? chaos_monkey(text) : text)
+  text = chaos_monkey(text) if chaos
+  text = wrap(text, wrap) if wrap
+
+  blob = FakeBlob.new(text)
   license_file = Licensee::LicenseFile.new(blob)
 
   actual = license_file.match
   assert actual, "No match for #{expected}."
-  assert_equal expected, actual.name, "expeceted #{expected} but got #{actual.name} for .match. Matches: #{license_file.matches}"
+  assert_equal expected, actual.name, "expeceted #{expected} but got #{actual.name} for .match. Confidence: #{license_file.confidence}. Method: #{license_file.matcher.class}"
+end
+
+def wrap(text, line_width=80)
+  text = text.clone
+  text.gsub! /([^\n])\n([^\n])/, '\1 \2'
+  text = text.split("\n").collect do |line|
+    line.length > line_width ? line.gsub(/(.{1,#{line_width}})(\s+|$)/, "\\1\n").strip : line
+  end * "\n"
+  text.strip
 end

data/test/test_licensee.rb

@@ -10,4 +10,8 @@ class TestLicensee < Minitest::Test
   should "detect a project's license" do
     assert_equal "mit", Licensee.license(fixture_path("licenses.git")).name
   end
+
+  should "diff a license" do
+    Licensee.diff(fixture_path("licenses.git"))
+  end
 end

data/test/test_licensee_exact_matcher.rb

@@ -0,0 +1,18 @@
+require 'helper'
+
+class TestLicenseeExactMatcher < Minitest::Test
+
+  def setup
+    text = File.open(Licensee::Licenses.find("mit").path).read.split("---").last
+    blob = FakeBlob.new(text)
+    @mit = Licensee::LicenseFile.new(blob)
+  end
+
+  should "match the license" do
+    assert_equal "mit", Licensee::ExactMatcher.match(@mit).name
+  end
+
+  should "know the match confidence" do
+    assert_equal 100, Licensee::ExactMatcher.new(@mit).confidence
+  end
+end

data/test/test_licensee_git_matcher.rb

@@ -0,0 +1,18 @@
+require 'helper'
+
+class TestLicenseeGitMatcher < Minitest::Test
+
+  def setup
+    text = license_from_path( Licensee::Licenses.find("mit").path )
+    blob = FakeBlob.new(text)
+    @mit = Licensee::LicenseFile.new(blob)
+  end
+
+  should "match the license" do
+    assert_equal "mit", Licensee::GitMatcher.match(@mit).name
+  end
+
+  should "know the match confidence" do
+    assert_equal 94, Licensee::GitMatcher.new(@mit).confidence
+  end
+end

data/test/test_licensee_levenshtein_matcher.rb

@@ -0,0 +1,34 @@
+require 'helper'
+
+class TestLicenseeLevenshteinMatcher < Minitest::Test
+
+  def setup
+    text = license_from_path( Licensee::Licenses.find("mit").path )
+    blob = FakeBlob.new(text)
+    @mit = Licensee::LicenseFile.new(blob)
+  end
+
+  should "match the license" do
+    assert_equal "mit", Licensee::LevenshteinMatcher.match(@mit).name
+  end
+
+  should "know the match confidence" do
+    matcher = Licensee::LevenshteinMatcher.new(@mit)
+    assert matcher.confidence > 98, "#{matcher.confidence} < 98"
+  end
+
+  should "calculate max delta" do
+    assert_equal 964.8000000000001, Licensee::LevenshteinMatcher.new(@mit).max_delta
+  end
+
+  should "calculate length delta" do
+    isc = Licensee::Licenses.find("isc")
+    assert_equal 2, Licensee::LevenshteinMatcher.new(@mit).length_delta(Licensee::Licenses.find("mit"))
+    assert_equal 334, Licensee::LevenshteinMatcher.new(@mit).length_delta(isc)
+  end
+
+  should "round up potential licenses" do
+    assert_equal 5, Licensee::LevenshteinMatcher.new(@mit).potential_licenses.size
+  end
+
+end

data/test/test_licensee_license.rb

@@ -8,7 +8,6 @@ class TestLicenseeLicense < Minitest::Test
 
   should "read the license body" do
     assert @license.body
-    assert @license.length > 0
     assert @license.text =~ /MIT/
   end
 

data/test/test_licensee_license_file.rb

@@ -14,17 +14,6 @@ class TestLicenseeLicenseFile < Minitest::Test
     assert @file.contents =~ /MIT/
   end
 
-  should "known the file length" do
-    assert_equal 1077, @file.length
-  end
-
-  should "calculate similiarty" do
-    actual = @file.send(:calculate_similarity, @mit)
-    assert actual > Licensee::CONFIDENCE_THRESHOLD, "expected #{actual} to be > 90% for MIT"
-    actual = @file.send(:calculate_similarity, @gpl)
-    assert actual < 1, "expected #{actual} to be < 1% for GPL"
-  end
-
   should "match the license" do
     assert_equal "mit", @file.match.name
   end
@@ -33,4 +22,8 @@ class TestLicenseeLicenseFile < Minitest::Test
     expected = "-Copyright (c) [year] [fullname]\n+Copyright (c) 2014 Ben Balter"
     assert @file.diff.include?(expected)
   end
+
+  should "calculate confidence" do
+    assert_equal 94, @file.confidence
+  end
 end

data/test/test_licensee_licenses.rb

@@ -3,8 +3,8 @@ require 'helper'
 class TestLicenseeLicenses < Minitest::Test
 
   should "know license names" do
-    assert_equal Array, Licensee::Licenses.names.class
-    assert_equal 15, Licensee::Licenses.names.size
+    assert_equal Array, Licensee::Licenses.send(:names).class
+    assert_equal 15, Licensee::Licenses.send(:names).size
   end
 
   should "load the licenses" do

data/test/test_licensee_matcher.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestLicenseeMatcher < Minitest::Test
+  should "match the license without raising an error" do
+    assert_nil Licensee::Matcher.match(nil)
+  end
+end

data/test/test_licensee_vendor.rb

@@ -8,10 +8,24 @@ class TestLicenseeVendor < Minitest::Test
     end
   end
 
-  should "detect each vendored license" do
+  should "detect each vendored license when modified" do
     licenses = Dir["#{Licensee::Licenses.base}/*"].shuffle
     licenses.each do |license|
       verify_license_file(license, true)
     end
   end
+
+  should "detect each vendored license with different line lengths" do
+    licenses = Dir["#{Licensee::Licenses.base}/*"].shuffle
+    licenses.each do |license|
+      verify_license_file(license, false, 50)
+    end
+  end
+
+  should "detect each vendored license with different line lengths when modified" do
+    licenses = Dir["#{Licensee::Licenses.base}/*"].shuffle
+    licenses.each do |license|
+      verify_license_file(license, true, 50)
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: licensee
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Ben Balter
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-02 00:00:00.000000000 Z
+date: 2014-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rugged
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.21.1b2
+- !ruby/object:Gem::Dependency
+  name: levenshtein-ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -96,6 +110,10 @@ files:
 - lib/licensee/license.rb
 - lib/licensee/license_file.rb
 - lib/licensee/licenses.rb
+- lib/licensee/matcher.rb
+- lib/licensee/matchers/exact_matcher.rb
+- lib/licensee/matchers/git_matcher.rb
+- lib/licensee/matchers/levenshtein_matcher.rb
 - lib/licensee/project.rb
 - lib/licensee/version.rb
 - test/fixtures/licenses.git/HEAD
@@ -108,9 +126,13 @@ files:
 - test/helper.rb
 - test/test_licensee.rb
 - test/test_licensee_bin.rb
+- test/test_licensee_exact_matcher.rb
+- test/test_licensee_git_matcher.rb
+- test/test_licensee_levenshtein_matcher.rb
 - test/test_licensee_license.rb
 - test/test_licensee_license_file.rb
 - test/test_licensee_licenses.rb
+- test/test_licensee_matcher.rb
 - test/test_licensee_project.rb
 - test/test_licensee_vendor.rb
 - vendor/choosealicense.com/_licenses/agpl-3.0.txt