rb_tags 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a67c84f973778879cabed5a52a9bf9b8d9328af9
+  data.tar.gz: 230f1a39761dff1665a17db4a88ca8b27c8debb9
+SHA512:
+  metadata.gz: b3d389f0dff8660b3d505906545683cea667711e3bf1b52855580637059d2e710dee798169175051a59f5395047790a2b9b7722f52692f889693f9802ef3db43
+  data.tar.gz: 54fd41a42fc5f63b2d0b3a63dab5597a3ed8d86599e650633d0241985cd3f6df2a2fad34f6526063c64093833813ed4b65a7e8c8206e9dd7ca2541cbfec99c83

data/.gitignore

@@ -0,0 +1,5 @@
+.tags
+.tags
+pkg/
+ToDos.md
+coverage/

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--require spec_helper
+--format documentation

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+gemspec
+
+gem 'simplecov', require: false, group: :test

data/Gemfile.lock

@@ -0,0 +1,103 @@
+PATH
+  remote: .
+  specs:
+    rb_tags (0.1.0)
+      bundler
+      colorize
+      gli
+      parallel
+      parslet
+      rake
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    awesome_print (1.6.1)
+    blankslate (3.1.3)
+    celluloid (0.16.0)
+      timers (~> 4.0.0)
+    coderay (1.1.0)
+    colorize (0.7.7)
+    diff-lcs (1.2.5)
+    docile (1.1.5)
+    ffi (1.9.8)
+    formatador (0.2.5)
+    gli (2.13.1)
+    guard (2.12.5)
+      formatador (>= 0.2.4)
+      listen (~> 2.7)
+      lumberjack (~> 1.0)
+      nenv (~> 0.1)
+      notiffany (~> 0.0)
+      pry (>= 0.9.12)
+      shellany (~> 0.0)
+      thor (>= 0.18.1)
+    guard-bundler (2.1.0)
+      bundler (~> 1.0)
+      guard (~> 2.2)
+      guard-compat (~> 1.1)
+    guard-compat (1.2.1)
+    guard-rspec (4.5.0)
+      guard (~> 2.1)
+      guard-compat (~> 1.1)
+      rspec (>= 2.99.0, < 4.0)
+    hitimes (1.2.2)
+    json (1.8.2)
+    listen (2.10.0)
+      celluloid (~> 0.16.0)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+    lumberjack (1.0.9)
+    method_source (0.8.2)
+    nenv (0.2.0)
+    notiffany (0.0.6)
+      nenv (~> 0.1)
+      shellany (~> 0.0)
+    parallel (1.6.0)
+    parslet (1.7.0)
+      blankslate (>= 2.0, <= 4.0)
+    pry (0.10.1)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (10.4.2)
+    rb-fsevent (0.9.5)
+    rb-inotify (0.9.5)
+      ffi (>= 0.5.0)
+    rspec (3.2.0)
+      rspec-core (~> 3.2.0)
+      rspec-expectations (~> 3.2.0)
+      rspec-mocks (~> 3.2.0)
+    rspec-core (3.2.3)
+      rspec-support (~> 3.2.0)
+    rspec-expectations (3.2.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-mocks (3.2.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-support (3.2.2)
+    shellany (0.0.1)
+    simplecov (0.10.0)
+      docile (~> 1.1.0)
+      json (~> 1.8)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.0)
+    slop (3.6.0)
+    terminal-notifier-guard (1.6.4)
+    thor (0.19.1)
+    timers (4.0.1)
+      hitimes
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  awesome_print
+  guard-bundler
+  guard-rspec
+  rb-fsevent
+  rb_tags!
+  rspec
+  simplecov
+  terminal-notifier-guard

data/Guardfile

@@ -0,0 +1,51 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features)
+
+## Uncomment to clear the screen before every task
+# clearing :on
+
+## Guard internally checks for changes in the Guardfile and exits.
+## If you want Guard to automatically start up again, run guard in a
+## shell loop, e.g.:
+##
+##  $ while bundle exec guard; do echo "Restarting Guard..."; done
+##
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+guard :bundler do
+  require 'guard/bundler'
+  require 'guard/bundler/verify'
+  helper = Guard::Bundler::Verify.new
+
+  files = ['Gemfile']
+  files += Dir['*.gemspec'] if files.any? { |f| helper.uses_gemspec?(f) }
+
+  # Assume files are symlinked from somewhere
+  files.each { |file| watch(helper.real_path(file)) }
+end
+
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 LeFnord
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,64 @@
+# RbTags
+
+Generate tags file for your ruby project and bundled gems, based on ctags.
+
+## Installation
+
+Install it using
+
+`gem install rb_tags`
+
+## Requirements
+
+The gem requires that you have
+
+* `find`
+* `ctags`
+
+in your path.
+
+## Usage
+
+`cd` into your project and simple type
+
+`rb_tags -h`
+
+```
+
+    NAME
+        rb_tags - Describe your application here
+
+    SYNOPSIS
+        rb_tags [global options] command [command options] [arguments...]
+
+    VERSION
+        0.0.5
+
+    GLOBAL OPTIONS
+        --help    - Show this message
+        --version - Display the program version
+
+    COMMANDS
+        find - search for a tag
+        help - Shows a list of commands or help for one command
+        show - show esisting tags
+        tag  - tags a given directory
+
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+
+## Author
+
+LeFnord
+
+## License
+
+see [License](LICENSE.txt)

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/rb_tags

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+
+require 'gli'
+require 'readline'
+
+begin # XXX: Remove this begin/rescue before distributing your app
+require 'rb_tags'
+self.extend RbTags
+rescue LoadError
+  STDERR.puts "In development, you need to use `bundle exec bin/rb_tags` to run your app"
+  STDERR.puts "At install-time, RubyGems will make sure lib, etc. are in the load path"
+  STDERR.puts "Feel free to remove this message from bin/rb_tags now"
+  exit 64
+end
+
+include GLI::App
+
+program_desc 'Describe your application here'
+
+version RbTags::VERSION
+
+subcommand_option_handling :normal
+arguments :strict
+
+# # global options
+# desc 'Describe some switch here'
+# switch [:s,:switch]
+#
+# desc 'Describe some flag here'
+# default_value 'the default'
+# arg_name 'The name of the argument'
+# flag [:f,:flagname]
+
+desc 'tags a given directory'
+command :tag do |c|
+  # switches
+  c.desc 'tag also bundled gems'
+  c.switch [:gems], :default_value => false
+
+  c.action do |global_options,options,args|
+    generate(options)
+  end
+end
+
+desc 'show esisting tags'
+command :show do |c|
+  c.action do |global_options,options,args|
+    ap tags
+    ap tags.length
+  end
+end
+
+desc 'search for a tag'
+command :find do |c|
+  c.action do |global_options,options,args|
+    find
+    ap @found
+    $stdout.print "open [#{(0 ... @found.length).to_a.join(',')}]: ".green
+    what = ''
+    while (what += $stdin.getch) !~ /(\w\s)/
+      $stdout.print "#{what}".blue
+    end
+    open what
+  end
+end
+
+pre do |global,command,options,args|
+  # Pre logic here
+  # Return true to proceed; false to abort and not call the
+  # chosen command
+  # Use skips_pre before a command to skip this block
+  # on that command only
+  true
+end
+
+post do |global,command,options,args|
+  # Post logic here
+  # Use skips_post before a command to skip this
+  # block on that command only
+end
+
+on_error do |exception|
+  # Error logic here
+  # return false to skip default error handling
+  true
+end
+
+# list = self.commands.keys.collect { |x| x.to_s }
+# args = complete(list)
+exit run(ARGV)

data/lib/rb_tags/concerns/completion.rb

@@ -0,0 +1,24 @@
+module Completion
+  module_function
+
+  def complete(list)
+    # :nocov:
+    comp = proc { |s| list.grep(/^#{Regexp.escape(s)}/) }
+
+    Readline.completer_word_break_characters = ""
+    Readline.completion_append_character = " "
+    Readline.completion_proc = comp
+
+    while line = Readline.readline('$ ', true)
+      unless line[-1] =~ /(\n\r)/
+        args = line.split(' ')
+        break
+      end
+    end
+
+    args
+    # :nocov:
+  end
+
+end
+

data/lib/rb_tags/concerns/generate_tags.rb

@@ -0,0 +1,30 @@
+module GenerateTags
+  # find ctags and split in single lines
+  def find_expressions(dir,mask)
+    found_tags = `find #{dir} -name '*.rb' | ctags -x -L -`.split("\n")
+    parse_expression_line(found_tags)
+    generate_hash
+  end
+
+  #parse found expression line
+  def parse_expression_line(found_tags)
+    @tags = []
+    found_tags.each do |tag_line|
+      begin
+        parsed_line = Parser.new.parse(tag_line)
+        @tags << ParserTransform.new.apply(parsed_line)
+      rescue Parslet::ParseFailed => error
+        message = ["[RbTags] Error: ", "line: ", "#{tag_line} ", "error: ", "#{error.cause.ascii_tree}"]
+        message.each { |m| $stdout.puts "#{m}" }
+        @tags << message.join("\n")
+      end
+    end
+
+    @tags
+  end
+
+  # converts array of hashes into single hash
+  def generate_hash
+    @tags.group_by{|x| x[:name]; x.delete(:name) }
+  end
+end

data/lib/rb_tags/concerns/parser.rb

@@ -0,0 +1,46 @@
+class Parser < Parslet::Parser
+  #atomic rules
+  rule(:space) { match['[:space:]'] }
+  rule(:spaces) { space.repeat(1) }
+  rule(:word) { match['\w'].repeat(1) }
+  rule(:line) { match['[:digit:]'].repeat(1) }
+  rule(:separator) { str('/') }
+
+  # composing rules
+  ## names, word-or_foo
+  rule(:name_adds) { match['$_-'] >> word.repeat(1) }
+  rule(:simple_name) { word.repeat(1) >> name_adds.repeat }
+  rule(:name) { match['$'].maybe >> simple_name >> match['\S'].maybe | match['\W'].repeat(1,3)}
+
+  ## part of path, word/
+  rule(:path) { separator >> match['\S'].repeat(1) }
+
+  ## full input
+  rule(:whole_line) {
+    name.as(:name) >> spaces >>
+    (word >> space >> word | word).as(:type) >> spaces >>
+    line.as(:line) >> spaces >>
+    path.as(:path) >> spaces >>
+    any.repeat.as(:definition)
+  }
+
+
+  root(:whole_line)
+end
+
+class ParserTransform < Parslet::Transform
+  rule(name: simple(:name),
+      type: simple(:type),
+      line: simple(:line),
+      path: simple(:path),
+      definition: simple(:definition)
+      ) {
+        {
+          name: name.str,
+          type: type.str,
+          line: line.str,
+          path: path.str,
+          definition: definition.str
+        }
+      }
+end

data/lib/rb_tags/concerns/sys_info.rb

@@ -0,0 +1,21 @@
+# author LeFnord
+# email  pscholz.le@gmail.com
+# date   2013-12-18
+
+
+module SysInfo
+  module_function
+
+  def number_of_processors
+    # :nocov:
+    if RUBY_PLATFORM =~ /linux/
+      return `cat /proc/cpuinfo | grep processor | wc -l`.to_i
+    elsif RUBY_PLATFORM =~ /darwin/
+      return `sysctl -n hw.logicalcpu`.to_i
+    else
+      return 2
+    end
+    # :nocov:
+  end
+
+end

data/lib/rb_tags/concerns/yaml_tasks.rb

@@ -0,0 +1,18 @@
+module YamlTasks
+  def read_from_yaml_file dir: nil
+    YAML.load_file(store(dir)) if File.exist?(store(dir))
+  end
+
+  def write_to_yaml dir: nil, this: {}
+    File.open(store(dir), 'w') {|out| YAML.dump this, out}
+  end
+
+  private
+  def store(dir = nil)
+    if !!dir
+      store = File.join(dir,".tags")
+    else
+      store = File.join(Dir.getwd,".tags")
+    end
+  end
+end

data/lib/rb_tags/tags.rb

@@ -0,0 +1,41 @@
+class Tags
+  include GenerateTags
+  include YamlTasks
+
+  attr_reader :dir, :tags, :names
+
+  def initialize(dir = Dir.getwd, read: false)
+    @dir = dir
+    if read
+      self.read
+      self.names
+    end
+  end
+
+  def tag
+    FileUtils.cd(@dir) { |dir| @tags = find_expressions(dir, @mask) }
+  end
+
+  def add(tags)
+    tags.each do |key,value|
+      if self.tags.key?(key)
+        self.tags[key] += value
+      else
+        self.tags[key] = value
+      end
+    end
+  end
+
+  def save
+    write_to_yaml(dir: @dir, this: @tags)
+  end
+
+  def read
+    @tags = read_from_yaml_file(dir: @dir)
+    tag if @tags.nil?
+  end
+
+  def names
+    @name ||= @tags.keys
+  end
+end

data/lib/rb_tags/version.rb

@@ -0,0 +1,3 @@
+module RbTags
+  VERSION = '0.1.0'
+end

data/lib/rb_tags.rb

@@ -0,0 +1,151 @@
+# external requirements
+require 'bundler'
+require 'awesome_print'
+require 'yaml'
+require 'readline'
+require 'parallel'
+require 'parslet'
+require 'parslet/convenience'
+require 'colorize'
+
+# internal requirements
+require 'rb_tags/version.rb'
+
+require 'rb_tags/concerns/sys_info'
+require 'rb_tags/concerns/generate_tags'
+require 'rb_tags/concerns/parser'
+require 'rb_tags/concerns/yaml_tasks'
+require 'rb_tags/concerns/completion'
+
+require 'rb_tags/tags'
+
+module RbTags
+  include SysInfo
+  include Completion
+
+  def generate(options={})
+    tags = Tags.new(default_dir)
+    tags.tag
+
+    default_options(options)
+    if @options[:gems]
+      result = tag_bundled_gems
+      result.each { |g| tags.add(g.tags) }
+    end
+
+    tags.save
+  end
+
+  def tag_bundled_gems
+    build_gem_list
+    results = ::Parallel.map(@gem_list.each_slice(number_of_processors),
+                             in_processes: number_of_processors) do |dir_list|
+      gem_list = Tags.new(dir_list.shift)
+      gem_list.tag
+
+      dir_list.each do |dir|
+        gem_tags = Tags.new(dir, read: true)
+        unless !!gem_tags.tags
+          gem_tags.tag
+          gem_tags.save
+          say_tagging(gem_tags.dir)
+        end
+        gem_list.add(gem_tags.tags)
+      end
+
+      gem_list
+    end
+
+    results
+  end
+
+  def say_tagging(dir)
+    $stdout.print "tag gem: ".blue
+    $stdout.print "#{dir}".colorize(:yellow_light)
+    $stdout.print " first time\n".blue
+  end
+
+  def tags
+    get_existend_tags
+    @tags.names
+  end
+
+  # used for command line
+  def find
+    get_existend_tags
+    arg = complete(@tags.names).first
+    @found = found(arg)
+  end
+
+  def found(arg)
+    @tags.tags[arg]
+  end
+
+  def open(what = 0)
+    if what !~ /\d+/
+      message = "\n       sorry '#{what.chomp!}' not yet supported ...\n       use an array index\n"
+      message.rjust(27).split(//).each do |char|
+        $stdout.print char.colorize(:light_red)
+        sleep 0.0057
+      end
+      return
+    end
+
+    opend_found selected: @found[what.to_i], editor: ENV['EDITOR']
+  end
+
+  # attributes
+  def options
+    @options
+  end
+
+  def gem_list
+    @gem_list
+  end
+
+
+  private
+
+  def get_existend_tags
+    @tags ||= Tags.new(read: true)
+  end
+
+  def build_gem_list
+    if File.exist? gem_file
+      @gem_list = Bundler.load.specs.map(&:full_gem_path) - [default_dir]
+    end
+  end
+
+  def gem_file
+    File.join(default_dir, './Gemfile')
+  end
+
+  def default_options(options)
+    @options = options.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+    @options.delete(:dir) if @options[:dir].nil?
+    @options.merge!(defaults) { |key, opt, default| opt }
+  end
+
+  def defaults
+    { gems: false }
+  end
+
+  def default_dir
+    Dir.getwd
+  end
+
+  def opend_found selected: {}, editor: 'mate'
+    # :nocov:
+    file_line = "#{selected[:line]} #{selected[:path]}"
+    case editor
+    when 'mate'
+      `mate -l #{file_line}`
+    when 'emacs'
+      `emacs --no-splash +#{file_line}`
+    else
+      `vim +#{file_line}`
+    end
+    # :nocov:
+  end
+
+end