rb_tags 0.1.0

data/rb_tags.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rb_tags/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rb_tags"
+  spec.version       = RbTags::VERSION
+  spec.authors       = ["LeFnord"]
+  spec.email         = ["pscholz.le@gmail.com"]
+
+  spec.summary       = %q{A wrapper around ctags.}
+  spec.description   = %q{A wrapper around ctags, with search for tag and open file if found.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "guard-bundler"
+  spec.add_development_dependency "rb-fsevent"
+  spec.add_development_dependency "terminal-notifier-guard"
+  spec.add_development_dependency "awesome_print"
+
+  spec.add_runtime_dependency "bundler"
+  spec.add_runtime_dependency "colorize"
+  spec.add_runtime_dependency "rake"
+  spec.add_runtime_dependency "parslet"
+  spec.add_runtime_dependency "parallel"
+  spec.add_runtime_dependency "gli"
+end

data/spec/parser_helper.rb

@@ -0,0 +1,22 @@
+def samples
+  [
+    "RbTags           module        1 /Users/le_fnord/sandbox/github/rb_tags/lib/rb_tags/version.rb module RbTags",
+    "ctags_expression method       18 /Users/le_fnord/sandbox/github/rb_tags/lib/rb_tags/gem_tags.rb def ctags_expression",
+    "generate         method       11 /Users/le_fnord/sandbox/github/rb_tags/lib/rb_tags/gem_tags.rb def generate",
+    "Parser           class         1 /Users/le_fnord/sandbox/github/rb_tags/lib/rb_tags/parser.rb class Parser < Parslet::Parser",
+    "add_to_hash      method       23 /Users/le_fnord/sandbox/github/rb_tags/lib/rb_tags/json.rb def add_to_hash(tag)",
+    "find_expressions method        2 /Users/le_fnord/sandbox/github/rb_tags/lib/rb_tags/generate_tags.rb def find_expressions(dir,mask)",
+    "generate         method       12 /Users/le_fnord/sandbox/github/rb_tags/lib/rb_tags.rb def generate(format: 'vim', gems: false)",
+    "initialize       method        5 /Users/le_fnord/sandbox/github/rb_tags/lib/rb_tags/gem_tags.rb def initialize(filename: \".gem_tags\", mask: '*.rb', format: 'vim')",
+    "initialize       method        6 /Users/le_fnord/sandbox/github/rb_tags/lib/rb_tags/tags.rb def initialize(dir: Dir.getwd, filename: \".tags\", mask: '*.rb', format: 'vim')",
+    "initialize       method       11 /Users/le_fnord/sandbox/github/rb_tags/lib/rb_tags/json.rb def initialize(tags)",
+    "parse            singleton method    3 /Users/le_fnord/sandbox/github/rb_tags/lib/rb_tags/json.rb def self.parse(tags)",
+
+    "*                method      189 /usr/local/var/rbenv/versions/2.2.1/lib/ruby/gems/2.2.0/gems/rake-10.4.2/lib/rake/file_list.rb def *(other)",
+    "<<               method      199 /usr/local/var/rbenv/versions/2.2.1/lib/ruby/gems/2.2.0/gems/rake-10.4.2/lib/rake/file_list.rb def <<(obj)",
+    "<=>              method        7 /usr/local/var/rbenv/versions/2.2.1/lib/ruby/gems/2.2.0/gems/rake-10.4.2/lib/rake/late_time.rb def <=>(other)",
+    "application=     method       12 /usr/local/var/rbenv/versions/2.2.1/lib/ruby/gems/2.2.0/gems/rake-10.4.2/lib/rake/rake_module.rb def application=(app)",
+    "L_darwin64_struct_ret_by_value_p$stub label       542 /usr/local/var/rbenv/versions/2.2.1/lib/ruby/gems/2.2.0/gems/ffi-1.9.8/ext/ffi_c/libffi/src/powerpc/darwin_closure.S L_darwin64_struct_ret_by_value_p$stub:",
+    "$retint          label       103 /usr/local/var/rbenv/versions/2.2.1/lib/ruby/gems/2.2.0/gems/ffi-1.9.8/ext/ffi_c/libffi/src/alpha/osf.S $retint:",
+  ]
+end

data/spec/rb_tags/concerns/completion_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Completion do
+  subject { described_class }
+
+  it { expect(subject.name).to eq 'Completion' }
+
+end

data/spec/rb_tags/concerns/generate_tags_spec.rb

@@ -0,0 +1,28 @@
+describe GenerateTags do
+  subject { described_class }
+
+  it { expect(subject.name).to eq 'GenerateTags' }
+
+  let(:valid) { ["RbTags           module        1 /Users/le_fnord/sandbox/github/rb_tags/lib/rb_tags/version.rb module RbTags"] }
+  let(:invalid) { ["Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua."] }
+
+  describe '#parse_expression_line' do
+    subject { Class.include described_class }
+    let(:tags) { subject.parse_expression_line(valid) }
+    let(:no_tags) { subject.parse_expression_line(invalid) }
+
+    describe 'valid example' do
+      it { expect {tags}.not_to raise_error }
+      it { expect(tags).to be_a Array }
+      it { expect(tags.first).to be_a Hash }
+      it { expect(tags.first).to include(:name, :type, :line, :path, :definition) }
+    end
+
+    describe 'invalid example' do
+      it { expect(no_tags).to be_a Array }
+      it { expect(no_tags.first).to be_a String }
+      it { expect(no_tags.first).to include('[RbTags] Error') }
+    end
+  end
+end
+

data/spec/rb_tags/concerns/parser_spec.rb

@@ -0,0 +1,107 @@
+describe Parser do
+  it { expect(described_class).to eq(Parser) }
+
+  let(:parser) { described_class.new }
+
+  describe 'atoms' do
+    describe '#space' do
+      it { expect(parser.space).to parse(' ') }
+      it { expect(parser.space).to parse("\t") }
+
+      it { expect(parser.space).not_to parse('   ') }
+      it { expect(parser.space).not_to parse('') }
+      it { expect(parser.space).not_to parse('1') }
+      it { expect(parser.space).not_to parse('a') }
+    end
+
+    describe '#spaces' do
+      it { expect(parser.spaces).to parse(' ') }
+      it { expect(parser.spaces).to parse("\t") }
+      it { expect(parser.spaces).to parse('  ') }
+      it { expect(parser.spaces).to parse("   \t") }
+      it { expect(parser.spaces).not_to parse('1') }
+      it { expect(parser.spaces).not_to parse('a') }
+    end
+
+    describe '#word' do
+      it { expect(parser.word).to parse('tags') }
+      it { expect(parser.word).to parse('RbTags') }
+      it { expect(parser.word).to parse('rb_tags') }
+
+      it { expect(parser.word).not_to parse(' ') }
+      it { expect(parser.word).not_to parse("\t") }
+      it { expect(parser.word).not_to parse('rb_tags/foo') }
+      it { expect(parser.word).not_to parse('RbTags::Foo') }
+    end
+
+    describe '#line' do
+      it { expect(parser.line).to parse('1') }
+      it { expect(parser.line).to parse('23') }
+
+      it { expect(parser.line).not_to parse(' ') }
+      it { expect(parser.line).not_to parse("\t") }
+      it { expect(parser.line).not_to parse("word") }
+    end
+
+    describe '#separator' do
+      it { expect(parser.separator).to parse('/') }
+
+      it { expect(parser.separator).not_to parse('1') }
+      it { expect(parser.separator).not_to parse('23') }
+      it { expect(parser.separator).not_to parse(' ') }
+      it { expect(parser.separator).not_to parse("\t") }
+      it { expect(parser.separator).not_to parse("word") }
+    end
+  end
+
+  describe 'composite' do
+    describe '#name' do
+      it { expect(parser.name).to parse('tags') }
+      it { expect(parser.name).to parse('RbTags') }
+      it { expect(parser.name).to parse('rb_tags') }
+      it { expect(parser.name).to parse('rb_tags_foo') }
+      it { expect(parser.name).to parse('rb-tags') }
+      it { expect(parser.name).to parse('rb-tags_foo') }
+      it { expect(parser.name).to parse('<<') }
+      it { expect(parser.name).to parse('$retint') }
+      it { expect(parser.name).to parse('L_darwin64_struct_ret_by_value_p$stub') }
+
+      it { expect(parser.name).not_to parse('RbTags::Foo') }
+      it { expect(parser.name).not_to parse('RbTags::Foo::Bar') }
+      it { expect(parser.name).not_to parse('rb_tags/foo') }
+      it { expect(parser.name).not_to parse('rb_tags.foo') }
+    end
+
+    describe '#path' do
+      it { expect(parser.path).to parse('/tags.rb') }
+      it { expect(parser.path).to parse('/RbTags.rb') }
+      it { expect(parser.path).to parse('/rb_tags.rb') }
+      it { expect(parser.path).to parse('/rb_tags_foo.rb') }
+
+      it { expect(parser.path).to parse('/foo/tags.rb') }
+      it { expect(parser.path).to parse('/foo/RbTags.rb') }
+      it { expect(parser.path).to parse('/foo/rb_tags.rb') }
+      it { expect(parser.path).to parse('/foo/rb_tags_foo.rb') }
+
+      it { expect(parser.path).to parse('/bar/foo/tags.rb') }
+      it { expect(parser.path).to parse('/bar/foo/RbTags.rb') }
+      it { expect(parser.path).to parse('/bar/foo/rb_tags.rb') }
+      it { expect(parser.path).to parse('/bar/foo/rb_tags_foo.rb') }
+
+      it { expect(parser.path).to parse('/barFoo/bar/foo_bar-foo/tags.rb') }
+      it { expect(parser.path).to parse('/barFoo/bar/foo_bar-foo/RbTags.rb') }
+      it { expect(parser.path).to parse('/barFoo/bar/foo_bar-foo/rb_tags.rb') }
+      it { expect(parser.path).to parse('/barFoo/bar/foo_bar-foo/rb_tags_foo.rb') }
+
+      it { expect(parser.path).to parse('/usr/local/var/rbenv/versions/2.2.1/lib/ruby/gems/2.2.0/gems/rake-10.4.2/lib/rake/file_list.rb') }
+    end
+  end
+
+  describe 'whole line' do
+    samples.each do |line|
+      it { expect(parser).to parse(line) }
+    end
+  end
+
+
+end

data/spec/rb_tags/concerns/sys_info_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe SysInfo do
+  subject { described_class }
+
+  it { expect(subject.name).to eq 'SysInfo' }
+
+  describe '#number_of_processors' do
+    let(:number) { subject.number_of_processors }
+
+    it 'does something' do
+      expect(subject).to receive(:number_of_processors).and_return(Fixnum)
+      subject.number_of_processors
+    end
+
+    it { expect(number).to be_a Fixnum }
+    it { expect(number).to be >= 2 }
+  end
+end

data/spec/rb_tags/concerns/yaml_tasks_spec.rb

@@ -0,0 +1,20 @@
+describe YamlTasks do
+  subject { described_class }
+
+  it { expect(subject.name).to eq 'YamlTasks' }
+
+  describe '#store' do
+    subject { Class.include described_class }
+    describe 'default dir' do
+      let(:store) { subject.send(:store) }
+
+      it { expect(store).to eq File.join(Dir.getwd,'.tags') }
+    end
+
+    describe 'dir given' do
+      let(:store) { subject.send(:store, '/somewhere') }
+
+      it { expect(store).to eq File.join('/somewhere',".tags") }
+    end
+  end
+end

data/spec/rb_tags/tags_spec.rb

@@ -0,0 +1,90 @@
+describe Tags do
+  before(:each) do
+    # tag_file = File.join(Dir.getwd,'.tags')
+    # FileUtils.rm(tag_file) if File.exist?(tag_file)
+  end
+
+  it { expect(described_class).to eq(Tags) }
+
+  subject { Tags.new }
+
+  it { expect(subject).to respond_to(:dir) }
+  it { expect(subject).to respond_to(:tags) }
+  it { expect(subject).to respond_to(:names) }
+
+  describe 'defaults' do
+    it { expect(subject.dir).to eq Dir.getwd }
+  end
+
+  describe 'with params' do
+    subject { Tags.new('.')}
+    it { expect(subject.dir).to eq '.' }
+  end
+
+  describe '#tag' do
+    it { expect(subject).to respond_to(:tag) }
+
+    it 'tags default directory' do
+      subject.tag
+      expect(subject.tags.length).to be > 1
+      expect(subject.tags).to be_a Hash
+      expect(subject.tags.values.first.first).to include(:type, :line, :path, :definition)
+    end
+
+    it 'tags specified directory' do
+      subject = Tags.new(FileUtils.pwd)
+      subject.tag
+      expect(subject.tags.length).to be > 1
+      expect(subject.tags).to be_a Hash
+      expect(subject.tags.values.first.first).to include(:type, :line, :path, :definition)
+    end
+  end
+
+  describe '#save' do
+    it { expect { subject.save }.not_to raise_error }
+    it 'do it' do
+      subject.save
+      foo = File.join(subject.dir, '.tags')
+      expect(File.exist?(foo)).to eq true
+    end
+  end
+
+  describe '#read' do
+    it { expect { subject.read }.not_to raise_error }
+    it 'do it' do
+      subject.tag
+      subject.save
+      tag_file = File.join(subject.dir, '.tags')
+      expect(File.exist?(tag_file)).to eq true
+      object = Tags.new
+      object.read
+      expect(object.tags).to eq subject.tags
+    end
+  end
+
+  describe '#add' do
+    subject { Tags.new }
+
+    it 'has same length, if both are equal' do
+      subject.tag
+      tags_1 = subject.tags
+      expect { subject.add(tags_1) }.not_to raise_error
+      expect(subject.tags.length).to eq tags_1.length
+    end
+
+    it 'has greater length, if not equal' do
+      dir = Bundler.load.specs.map(&:full_gem_path).last
+      compare = Tags.new(dir)
+      subject.tag
+      compare.tag
+      subject.add(compare.tags)
+      expect(subject.tags.length).to be > compare.tags.length
+    end
+  end
+
+  describe '#names' do
+    before { subject.tag }
+    it { expect(subject.names).to be_a Array }
+    it { expect(subject.names.first).to be_a String }
+  end
+end

data/spec/rb_tags_spec.rb

@@ -0,0 +1,135 @@
+class Foo
+  include RbTags
+end
+
+describe RbTags do
+  it 'has a version number' do
+    expect(RbTags::VERSION).not_to be nil
+  end
+
+  subject { Class.include RbTags }
+
+  it { expect(described_class).to eq(RbTags) }
+  it { expect(subject).to respond_to(:generate) }
+  it { expect(subject).to have_attributes(options: nil, gem_list: nil) }
+
+  context Foo do
+    let(:foo) { Foo.new }
+
+    describe '#generate' do
+      describe 'in work dir' do
+        it { expect { foo.generate }.to_not raise_error }
+      end
+
+      describe 'in gems' do
+        it { expect { foo.generate(gems: true) }.to_not raise_error }
+      end
+    end
+
+    describe '#say_tagging' do
+      let(:dir) { '/something' }
+      let(:message) { "tag gem: #{dir} first time\n"}
+
+      it 'does something' do
+        expect(foo).to receive(:say_tagging).with(dir).and_return(message)
+        foo.say_tagging(dir)
+      end
+    end
+
+    describe '#tags' do
+      let(:tag_tags) { Tags.new(read: true).names}
+
+      it 'has tags' do
+        expect(foo.tags).to eq tag_tags
+      end
+    end
+
+    describe '#find' do
+      let(:tag) { Tags.new(read: true).tags}
+      let(:arg) { tag.first.first }
+
+      before do
+        foo.send(:get_existend_tags)
+        allow(foo).to receive(:complete).and_return(tag[arg])
+      end
+
+      it 'does something' do
+        expect(foo.found(arg)).to eq tag[arg]
+        foo.find
+      end
+    end
+
+    describe '#found' do
+      let(:tag) { Tags.new(read: true).tags.first}
+      let(:key) { tag.first }
+
+      it 'does something' do
+        foo.send(:get_existend_tags)
+        expect(foo.found(key)).to eq tag.last
+      end
+    end
+
+    describe '#open' do
+      describe 'what is valid' do
+        let(:what) { 0 }
+
+        it 'call open' do
+          expect(foo).to receive(:open).with(what)
+          foo.open(what)
+        end
+      end
+
+      describe 'what is invalid' do
+        let(:what) { 'a' }
+
+        it { expect{ foo.open(what) }.to output.to_stdout }
+      end
+    end
+
+    describe 'private methods' do
+      describe '#default_options' do
+        describe 'defaults' do
+          let(:tags) { foo.send(:default_options, {})}
+          let(:defaults) { foo.send(:defaults) }
+          let(:default) { {gems: false} }
+
+          it { expect { tags }.to_not raise_error }
+          it { expect(tags).to eq defaults }
+          it 'has defaults' do
+            defs = foo.send(:default_options, {})
+            expect(defs).to eq default
+            expect(foo.options).to eq default
+          end
+        end
+
+        describe 'set gems' do
+          let(:options) { {gems: true} }
+          let(:tag_w_options) { foo.send(:default_options, options)}
+          it { expect(tag_w_options).to eq options }
+        end
+
+        describe 'from gli' do
+          let(:income) { { "dir" => "..", :dir => "..", "save" => true, :save => true, "gems" => true, :read  => false } }
+          let(:options) { foo.send(:default_options, income)}
+          let(:expected) { { :dir => "..", :save => true, :gems => true, :read  => false } }
+
+          it { expect(options).to eq expected }
+        end
+      end
+
+      describe '#gem_list' do
+        let(:bar) { foo.send(:build_gem_list) }
+
+        it { expect(bar).to be_a Array }
+        it { expect(bar).to_not include(foo.send(:default_dir))}
+      end
+
+      describe '#get_existend_tags' do
+        let(:tags) { foo.send(:get_existend_tags) }
+
+        it { expect(tags).to be_a Tags }
+      end
+
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,88 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter "/spec/"
+end
+
+
+require 'rspec'
+require 'rspec/mocks'
+require 'parslet/rig/rspec'
+
+require 'parser_helper'
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'rb_tags'
+
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end