comment_extractor 1.0.1

data/spec/comment_extractor/extractor_manager_spec.rb

@@ -0,0 +1,233 @@
+require 'spec_helper'
+require 'comment_extractor/extractor_manager'
+
+module CommentExtractor
+  describe ExtractorManager do
+    after do
+      if described_class.instance_variable_defined?(:@extractors)
+        described_class.send(:remove_instance_variable, :@extractors)
+      end
+    end
+
+    def registered_extractors
+      described_class.instance_variable_get(:@extractors)
+    end
+
+    describe 'PublicModuleMethods' do
+      describe '.regist_extractor' do
+        subject { registered_extractors }
+
+        before do
+          described_class.regist_extractor(extractor)
+        end
+
+        let(:extractor) { :Object }
+
+        context "given a extractor's symbol or Klass" do
+          it 'registers a extractor to self' do
+            expect(subject).to have_key(extractor)
+          end
+        end
+      end
+
+      describe '.default_extractors' do
+        subject { described_class.default_extractors }
+
+        it 'returns Array contains default extractors' do
+          expect(subject).to be_an_instance_of Array
+        end
+      end
+    end
+
+    describe 'Finding extractor methods' do
+      before do
+        described_class.instance_variable_set(:@extractor_definitions, definitions)
+      end
+
+      let(:definitions) do
+        {
+          shebang: {
+            regexp: /(\/node$)|(ruby$)/,
+            values: ['JavaScript', 'Ruby']
+          },
+          filename: {
+            regexp: /(\.js$)|(\.rb$|Gemfile$|Rakefile)/,
+            values: ['JavaScript', 'Ruby']
+          },
+          filetype: {
+            'key' => 'value',
+          }
+        }
+      end
+
+      shared_context 'trying to find extractor' do
+        context 'given a registered value' do
+          let(:test_value) { registed_value }
+          it 'finds ExtractorKlass' do
+            should eql 'Ruby'
+          end
+        end
+
+        context 'given a non-matching string' do
+          let(:test_value) { '' }
+          it { should be_nil }
+        end
+      end
+
+      describe '.find_extractor_by_shebang' do
+        subject { described_class.find_extractor_by_shebang(test_value) }
+        let(:registed_value) { '#! /usr/local/ruby' }
+
+        it_behaves_like 'trying to find extractor'
+      end
+
+      describe '.find_extractor_by_filename' do
+        subject { described_class.find_extractor_by_filename(test_value) }
+        let(:registed_value) { 'path/to/file.rb' }
+
+        it_behaves_like 'trying to find extractor'
+      end
+
+      describe '.find_extractor_by_filetype' do
+        subject { described_class.find_extractor_by_filetype('key') }
+
+        it 'finds ExtractorKlass by matching file type' do
+          should eql 'value'
+        end
+      end
+
+      describe '.can_extract' do
+        subject { described_class.can_extract(file_path) }
+
+        before do
+          allow(File).to receive(:binary?).with(file_path) { binary? }
+          allow(File).to receive(:shebang).with(file_path) { shebang }
+        end
+
+        let(:file_path) { '/path/to/file' }
+        let(:shebang) { nil }
+        let(:binary?) { false }
+
+        context 'given a binary file' do
+          let(:binary?) { true }
+          it { should be_nil }
+        end
+
+        context 'given a file that does not contain shebang' do
+          let(:file_path) { '/path/to/ruby.rb' }
+
+          it 'finds ExtractorKlass by file name' do
+            should eql 'Ruby'
+          end
+        end
+
+        context 'given a file that contains shebang' do
+          let(:shebang) { '/usr/bin/node' }
+
+          it 'finds ExtractorKlass by shebang' do
+            should eql 'JavaScript'
+          end
+        end
+
+        context 'when extractor is not found' do
+          before do
+            allow(::CommentExtractor).to receive(:configuration).
+              and_return(stub_configuration)
+            allow(ExtractorManager).to receive(:find_extractor_by_shebang).
+              and_return(nil)
+            allow(ExtractorManager).to receive(:find_extractor_by_filename).
+              and_return(nil)
+          end
+
+          let(:stub_configuration) do
+            double.tap do |c|
+              allow(c).to receive(:default_extractor).and_return(default_extractor)
+              allow(c).to receive(:use_default_extractor).and_return(use_default_extractor)
+            end
+          end
+          let(:default_extractor) { Extractor }
+
+          context 'when configuration.use_default_extractor is true' do
+            let(:use_default_extractor) { true }
+            it 'uses default extractor as an alternative to specific scanner' do
+              expect(subject).to eql default_extractor
+            end
+          end
+
+          context 'when configuration.use_default_extractor is true' do
+            let(:use_default_extractor) { false }
+            it 'does not uses default extractor as an alternative to specific scanner' do
+              expect(subject).to be_nil
+            end
+          end
+        end
+      end
+    end
+
+    context 'PrivateModuleMethods' do
+      describe '.initialize_extractors!' do
+        subject { registered_extractors }
+
+        let(:described_method) { described_class.send(:initialize_extractors!) }
+        let(:default_extractors) { ExtractorManager.default_extractors }
+
+        it 'initializes extractors' do
+          expect(subject).to be_nil
+          described_method
+          expect(registered_extractors.keys).to match_array default_extractors
+        end
+      end
+
+      describe '.build_extractor_definitions' do
+        subject { described_class.send(:build_extractor_definitions) }
+
+        before do
+          allow(described_class).to receive(:extractors).and_return(extractors)
+        end
+
+        def build_extractor(name)
+          double.tap do |e|
+            allow(e).to receive(:disabled?).and_return(false)
+            allow(e).to receive(:shebang).and_return(/#{name}/)
+            allow(e).to receive(:filetype).and_return(name)
+            allow(e).to receive(:filename).and_return(/\.#{name}$/)
+          end
+        end
+
+        let(:extractors) do
+          {
+            Ruby: ruby_extractor,
+            Php: php_extractor,
+          }
+        end
+        let(:php_extractor) { build_extractor('php') }
+        let(:ruby_extractor) { build_extractor('ruby') }
+        let(:expected_regexp) do
+          {
+            shebang: /(ruby)|(php)/,
+            filename: /(\.ruby$)|(\.php$)/,
+            filetype: {
+              'php' => php_extractor,
+              'ruby' => ruby_extractor,
+            },
+          }
+        end
+        let(:defined_extractor_finders) do
+          described_class.send(:defined_extractor_finders)
+        end
+
+        it 'builds extractor definitions' do
+          expect(subject).to be_an_instance_of Hash
+
+          [:filename, :shebang].each do |finder|
+            expect(subject[finder]).to be_an_instance_of Hash
+            expect(subject[finder][:regexp]).to eql expected_regexp[finder]
+            expect(subject[finder][:values]).to be_an_instance_of Array
+          end
+
+          expect(subject[:filetype]).to eql expected_regexp[:filetype]
+        end
+      end
+    end
+  end
+end

data/spec/comment_extractor/extractor_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+require 'comment_extractor/extractor'
+
+module CommentExtractor
+  describe Extractor do
+    let(:content) { File.read(__FILE__) }
+    let(:scanner_object) { Extractor.new(content) }
+
+    describe 'ClassMethods' do
+      let(:scanner_klass) { Extractor }
+
+      describe '.new' do
+        subject { scanner_object }
+        it { expect { subject }.to_not raise_error }
+
+        it 'initializes attributes' do
+          expect(subject.content).to eql content
+          expect(subject.code_objects).to be_an_instance_of CodeObjects
+        end
+      end
+
+      describe '.disable!' do
+        it 'disables own status' do
+          expect(scanner_klass.disabled?).to be_falsy
+          scanner_klass.disable!
+          expect(scanner_klass.disabled?).to be_truthy
+        end
+      end
+
+      describe 'schema' do
+        after do
+          scanner_klass.send(:remove_instance_variable, :@schema)
+        end
+
+        shared_examples_for 'a setting schema' do
+          before do
+            scanner_klass.send(key, value)
+          end
+
+          it 'defines schemas for own' do
+            expect(scanner_klass.schema).to eql({ key => value })
+          end
+        end
+
+        describe '.shebang' do
+          let(:value) { %r!#\! path/to/test! }
+          let(:key) { :shebang }
+          it_should_behave_like 'a setting schema'
+        end
+
+        describe '.filetype' do
+          let(:value) { 'ruby' }
+          let(:key) { :filetype }
+          it_should_behave_like 'a setting schema'
+        end
+
+        describe '.filename' do
+          let(:value) { /\.rb$/ }
+          let(:key) { :filename }
+          it_should_behave_like 'a setting schema'
+        end
+      end
+    end
+
+    describe 'PublicInstanceMethods' do
+      describe '#extract_comments' do
+        subject { scanner_object.extract_comments }
+        it { expect { subject }.to raise_error(NotImplementedError) }
+      end
+    end
+
+    describe 'ProtectedInstanceMethods' do
+      describe '#scan' do
+        subject { scanner_object.send(:scan) }
+        it { expect { subject }.to raise_error(NotImplementedError) }
+      end
+
+      describe '#scanner' do
+        subject { scanner_object.send(:scanner) }
+        it { should be_an_instance_of(StringScanner) }
+      end
+
+      describe '#build_comment' do
+        subject { scanner_object.send(:build_comment, 1, 'comment') }
+        it { should be_an_instance_of CodeObject::Comment }
+      end
+
+      describe '#content' do
+        subject { scanner_object.content }
+        it { should be_an_instance_of String }
+      end
+    end
+
+    describe 'PrivateInstanceMethods' do
+      describe '#raise_report' do
+        subject { scanner_object.send(:raise_report) }
+
+        it { expect { subject }.to raise_error(Extractor::SyntaxDefinitionError) }
+      end
+    end
+  end
+end

data/spec/comment_extractor/file_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+require 'comment_extractor/file'
+require 'tempfile'
+
+using CommentExtractor::DetectableSchemeFile
+
+module CommentExtractor
+  describe DetectableSchemeFile do
+    let(:file) { File.new(file_path) }
+    let(:asset_dir) { File.expand_path('../../assets', __FILE__) }
+    let(:binary_path) { "#{asset_dir}/binary_file" }
+
+    describe 'ClassMethods' do
+      describe '.shebang' do
+        subject { File.shebang(file.path) }
+        let(:file_path) do
+          Tempfile.new('tempfile').tap do |f|
+            f.write(content)
+            f.flush
+            f.path
+          end
+        end
+        let(:content) { '' }
+
+        before do
+          allow(File).to receive(:extname).and_return(extname)
+        end
+
+        context 'when initialized file with a extension' do
+          let(:extname) { '.rb' }
+          it { should be_nil }
+        end
+
+        context 'when initialized file with no extension' do
+          let(:extname) { '' }
+
+          context 'content has no shebang' do
+            it 'does not detect shebang' do
+              should be_nil
+            end
+          end
+
+          context 'content has a shebang' do
+            let(:content) { "#! /usr/local/bin/ruby\n" }
+
+            it 'detects shebang' do
+              should eql '/usr/local/bin/ruby'
+            end
+          end
+        end
+      end
+
+      describe '.binary?' do
+        subject { File.binary?(file_path) }
+
+        context 'given the binary file' do
+          let(:file_path) { binary_path }
+          it { should be_truthy }
+        end
+
+        context 'given the source file' do
+          let(:file_path) { __FILE__ }
+          it { should be_falsy }
+        end
+      end
+    end
+
+    describe '#read_content' do
+      subject { file.read_content }
+
+      context 'given a binary_file' do
+        let(:file_path) { binary_path }
+        it { should be_nil }
+      end
+
+      context 'given a source code file' do
+        let(:file_path) { __FILE__ }
+
+        it "returns file's content" do
+          should eql File.read(file_path)
+        end
+
+        context 'contains shebang' do
+          let(:body) { 'HelloWorld' }
+          let(:file_path) do
+            Tempfile.new('tempfile').tap do |f|
+              f.write("#! /usr/local/shebang\n#{body}")
+              f.flush
+              f.path
+            end
+          end
+
+          it 'equals the result without shebang' do
+            should eql body
+          end
+        end
+      end
+    end
+  end
+end

data/spec/comment_extractor/parser_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+require 'comment_extractor/parser'
+
+using CommentExtractor::DetectableSchemeFile
+
+module CommentExtractor
+  describe Parser do
+    let(:expected_comments) { [] }
+    let(:stub_extractor) do
+      Class.new(CommentExtractor::Extractor).tap do |extractor|
+        allow(extractor).to receive(:extract_comments).and_return(expected_comments)
+      end
+    end
+
+    describe 'InstanceMethods' do
+      let(:parser) { described_class.new(stub_extractor) }
+
+      describe '#extract_comments' do
+        subject { parser.extract_comments }
+
+        context 'when initialized by a correct type Extractor' do
+          before do
+            expect(stub_extractor).to receive(:extract_comments).once
+          end
+
+          it 'parses file and returns comments' do
+            expect(subject).to be_an_instance_of Array
+          end
+        end
+
+        context 'when initialized by not instance of Extractor' do
+          let(:parser) { described_class.new(nil) }
+          it { expect { subject }.to raise_error(TypeError) }
+        end
+      end
+    end
+
+    describe 'ClassMethods' do
+      describe '.for' do
+        subject { described_class.for(file_path) }
+        let(:file_path) { __FILE__ }
+
+        context 'when extractor is found' do
+          before do
+            allow(ExtractorManager).to receive(:can_extract).
+              and_return(stub_extractor)
+          end
+
+          it 'initializes extractor' do
+            expect(subject).to be_an_instance_of described_class
+            extractor = subject.extractor
+            expect(extractor).to be_a Extractor
+            expect(extractor.code_objects.file).to eql file_path
+          end
+        end
+      end
+
+      describe '.new' do
+        subject { described_class.new(stub_extractor) }
+
+        it 'initializes a instance of Parser' do
+          expect { subject }.to_not raise_error
+        end
+      end
+    end
+  end
+end

data/spec/comment_extractor/smart_string_scanner_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'comment_extractor/smart_string_scanner'
+
+using CommentExtractor::SmartStringScanner
+
+module CommentExtractor
+  describe SmartStringScanner do
+    let(:scanner) { StringScanner.new("...\n...") }
+
+    describe 'refines #current_line' do
+      context 'when scanner has already used' do
+        it 'returns current line number' do
+          expect(scanner.current_line).to eql 1
+
+          scanner.scan(/^.*$/) # Scanning one line
+          expect(scanner.current_line).to eql 1
+
+          scanner.scan(/\n/) # Go to next line
+          expect(scanner.current_line).to eql 2
+        end
+      end
+    end
+  end
+end

data/spec/comment_extractor/version_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'comment_extractor/version'
+
+describe 'CommentExtractor::Version' do
+  subject { CommentExtractor }
+  it { should be_const_defined(:Version) }
+  it { should be_const_defined(:VERSION) }
+end

data/spec/comment_extractor_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+require 'comment_extractor'
+
+describe CommentExtractor do
+  describe 'ClassMethods' do
+    describe '.configuration' do
+      subject { described_class.configuration }
+      it { should be_an_instance_of CommentExtractor::Configuration }
+    end
+
+    describe '.configure' do
+      it { expect { |b| described_class.configure(&b) }.to yield_control }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+require 'rspec'
+
+begin
+  require 'coveralls'
+  Coveralls.wear!
+rescue LoadError
+end
+
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift File.expand_path('../support', __FILE__)
+require 'rspec/comment_extractor'
+
+RSpec.configure do |config|
+  config.order = 'random'
+  config.run_all_when_everything_filtered = true
+  config.show_failures_in_pending_blocks = true
+  config.raise_errors_for_deprecations!
+  config.include RSpec::CommentExtractor::ExtractorExampleGroup, type: :extractor, example_group: {
+    file_path: Regexp.compile(%w[spec comment_extractor extractor .*.rb].join('[\\\/]'))
+  }
+  config.source_code_path = 'spec/assets/source_code'
+end

data/spec/support/rspec/comment_extractor/extractor_example_group.rb

@@ -0,0 +1,115 @@
+RSpec.configure do |config|
+  config.add_setting :source_code_path, default: 'spec/assets/source_code'
+end
+
+module RSpec::CommentExtractor::ExtractorExampleGroup
+  include RSpec::CommentExtractor::Matchers::ExtractComment
+
+  def build_extractor(content = nil)
+    described_class.new(content)
+  end
+
+  def source_code_path(file_name = nil)
+    dir = RSpec.configuration.source_code_path
+    file_name ? "#{dir}/#{file_name}" : dir
+  end
+
+  def self.included(k)
+    k.class_eval do
+      # Initialize shared_examples
+      shared_examples_for 'extracting comments from' do |*file_names|
+        context '.extract_comments' do
+          raise 'file_names did not given' if file_names.empty?
+
+          file_names.each do |file_name|
+            context "given a content in #{file_name}" do
+              let(:path) { source_code_path(file_name) }
+              let(:content) { File.open(path) { |f| f.read } }
+              let(:expected_comments) do
+                content.split("\n").each_with_object({}) do |line, memo|
+                  if %r!(?<comment>\[-(?<line_number>\d+)-\].*)$! =~ line
+                    comment.sub!(/(?<=\[-end-\]).*$/, '') if comment =~ /\[-end-\]/
+                    memo[line_number.to_i] = comment
+                  end
+                end
+              end
+              let(:extracted_comments) { extractor.extract_comments }
+
+              it 'scans content' do
+                expect { extracted_comments }.to extract_comment(expected_comments)
+              end
+            end
+          end
+        end
+      end
+
+      shared_examples_for 'a schema' do |key, *expected_list|
+        let(:schema) { extractor.class.send(key) }
+
+        expected_list.each do |expected|
+          context "Given '#{expected}'" do
+            it "detects extractor" do
+              expect(expected).to match schema
+            end
+          end
+        end
+
+        # Schema does not have to contain group regexp because of the optimization.
+        it 'does not contain group regexp; You need to remove `/()/`' do
+          matcher = Regexp.new([schema.source, /.*/.source].join('|'))
+
+          expect(matcher.match('_').length).to eql 1
+        end
+      end
+
+      shared_examples_for 'detecting shebang' do |*shebangs|
+        describe '.shebang' do
+          it_behaves_like 'a schema', :shebang, *shebangs
+        end
+      end
+
+      shared_examples_for 'detecting filename' do |*filenames|
+        describe '.filename' do
+          it_behaves_like 'a schema', :filename, *filenames
+        end
+      end
+
+      # Initialize example groups and run test
+      metadata[:type] = :extractor
+
+      let(:content) { '' }
+      let(:extractor) { build_extractor(content) }
+
+      context '.filetype' do
+        subject { extractor.class.filetype }
+
+        it 'should be defined' do
+          should_not be_nil
+        end
+
+        it 'defines a instance of Array or String' do
+          string_or_array = subject.is_a?(String) || subject.is_a?(Array)
+          expect(string_or_array).to be_truthy
+        end
+      end
+
+      # Skips test when extractor has already disabled
+      if metadata[:disabled]
+        shared_examples_for 'disabled' do
+          subject { described_class.disabled? }
+          it { expect(subject).to be_truthy }
+        end
+
+        it_behaves_like 'disabled'
+
+        pending 'disabled extractor'
+
+        next
+      else
+        context '.new' do
+          it { expect { extractor }.to_not raise_error }
+        end
+      end
+    end
+  end
+end