temill 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1155d75f0ef504687a7d27f1e32e5f78fba0bfec
+  data.tar.gz: 27230f848bea78c6b73c77a9447c4b423e84efd8
+SHA512:
+  metadata.gz: 6c1b8272fab37933ca4dca81c021076b54f14eef52964627f3ce75a588288e755fba9791a4ed97a8cb8d42c5966c85c3c931c28b088e5553abaca7a5623066fc
+  data.tar.gz: 60e8050055d35c03a5e43c9ae75b4a72cabc27d3cac1fda9668a3af24def3eb9d699f1652afae4fff8d0c71e26b93395964f4bc1e34b8d610e7e5bab0dfa1525

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.13.1

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in temill.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Yusuke Takeuchi
+
+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,101 @@
+# Temill
+
+Temill shows objects to embedded comments in source code.
+
+## Sample
+```ruby
+require 'temill'
+
+Temill.show('Hello!, World!')
+
+Temill.show <<-EOT
+  You can use
+  heredoc
+EOT
+
+5.times{| i |
+  Temill.show(i ** 5)
+}
+
+Temill.show(
+  %w(More complex arguments).map{| s |
+    [s, s.upcase, s.downcase]
+  }
+)
+
+Temill.emit
+```
+will output
+```ruby
+#--------------------------------
+#/path/to/source.rb
+#--------------------------------
+require 'temill'
+
+Temill.show('Hello!, World!')
+# temill showing 1 results for line 3 (line 3 in this output)
+# "Hello!, World!"
+
+Temill.show <<-EOT
+  You can use
+  heredoc
+EOT
+# temill showing 1 results for line 5 (line 7 in this output)
+# "  You can use\n  heredoc\n"
+
+5.times{| i |
+  Temill.show(i ** 5)
+  # temill showing 5 results for line 11 (line 15 in this output)
+  # 0
+  # 1
+  # 32
+  # 243
+  # 1024
+}
+
+Temill.show(
+  %w(More complex arguments).map{| s |
+    [s, s.upcase, s.downcase]
+  }
+)
+# temill showing 1 results for line 14 (line 24 in this output)
+# [["More", "MORE", "more"],
+#  ["complex", "COMPLEX", "complex"],
+#  ["arguments", "ARGUMENTS", "arguments"]]
+
+Temill.emit
+```
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'temill'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install temill
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/YusukeTakeuchi/temill.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "temill"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/temill/core.rb

@@ -0,0 +1,305 @@
+require 'pp'
+require 'digest/sha2'
+require 'awesome_print'
+
+# most features are implemented in TemillImpl
+# @see Temill::TemillImpl
+class Temill
+
+  # @param [Hash] opts
+  # @option opts [String] :default_indent indent string used when indent guess fails
+  #                                       (defaults to '    ')
+  # @option opts [Integer] :tabstop the number of spaces a tab counts for.
+  #                                 make sense only if both spaces and tabs are used in a line
+  #                                 (defaults to 4)
+  # @option opts [bool] :compact if true, show only lines that #show methods called are involved
+  #                              (defaults to false)
+  # @option opts [Symbol,#call] :inspect method to convert obj into String
+  #                              (defaults to :pretty_inspect)
+  def initialize(**opts)
+    _initialize(**opts)
+  end
+
+  EVAL_PATH_PREFIX = '(temill eval)/'
+
+  DefaultOptions = {
+    tabstop: 4,
+    default_indent: '  ',
+    compact: false,
+    inspect: :pretty_inspect
+  }
+
+  # Implementation of Temill:
+  # this module will be both included and extended to Temill
+  module TemillImpl
+    def _initialize(**options)
+      @options = DefaultOptions.merge(options)
+      reset
+    end
+
+    # clear all results added by #show
+    def reset
+      # absolute_path => SourceFile
+      @source_files = {}
+      self
+    end
+
+    # set options
+    # @see Temil#initialize
+    def set_options(**options)
+      @options.update(options)
+      self
+    end
+
+    # store values to be shown. You have to use emit to actually output the results.
+    # @overload show(val)
+    #   @param [Object] val value to show
+    # @overload show(*vals)
+    #   @param [Array<Object>] vals values to show
+    # @overload show(&block)
+    #   show the result of block
+    # @return [Object] the object shown
+    def show(*vals, &block)
+      if not vals.empty? and block
+        raise ArgumentError, 'either value or block can be specified'
+      end
+
+      loc = caller_locations.first
+      path = loc.absolute_path
+
+      sf = (@source_files[path] ||= SourceFile.from_path(path, @options))
+
+      if block
+        obj = block.call
+      else
+        case vals.size
+        when 0
+          obj = nil
+        when 1
+          obj = vals.first
+        else
+          obj = vals
+        end
+      end
+      sf.add_result(loc, obj, block_given?)
+
+      obj
+    end
+
+    # same as Kernel.eval, but the evaluated code is handled as if
+    # it was an independent file.
+    # @param [String] src
+    # @param [Binding] bind
+    # @param [String] fname
+    def eval(src, bind=TOPLEVEL_BINDING, fname=default_eval_fname(caller_locations.first))
+      path = EVAL_PATH_PREFIX + Digest::SHA256.hexdigest(src) + '/' + fname
+      @source_files[path] ||= SourceFile.from_inline_source(src, path, @options)
+      Kernel.eval(src, bind, path)
+    end
+
+    private def default_eval_fname(loc)
+      "#{File.basename(loc.path)}:#{loc.lineno}:#{loc.base_label}"
+    end
+
+    # output results to stdout or any IO
+    # @param [IO] f IO to output to
+    def emit(f=$stdout)
+      execute_emitter(Emitters::StdoutEmitter.new(f, @options))
+    end
+
+    # output results to files in a directory.
+    # a file of original source code corresponds to a output file.
+    # @param [String] dir
+    def emit_to_directory(dir)
+      execute_emitter(Emitters::DirectoryEmitter.new(dir, @options))
+    end
+
+    # output results to strings.
+    # @return [Hash<String,String>] the keys are filenames and the values are the result for the file
+    def emit_to_string
+      execute_emitter(Emitters::StringEmitter.new(@options))
+    end
+
+    # @param [#call] emitter
+    def execute_emitter(emitter=nil, &block)
+      if emitter
+        emitter.call(@source_files.values, &block)
+      elsif block
+        block.call(@source_files.values)
+      else
+        raise ArgumentError, 'no emitter specified'
+      end
+    end
+
+  end
+
+  class SourceFile
+    attr_reader :path, :lines, :sexp
+    attr_reader :insertion_points
+
+    def initialize(src, path, options)
+      @path = path
+      @lines = [nil] + src.lines
+      @sexp = Ruby23Parser.new.parse(src, path).value
+      @options = options
+      @insertion_points = InsertionPointSet.new
+    end
+
+    def self.from_inline_source(src, virtual_path, options)
+      new(src, virtual_path, options)
+    end
+
+    def self.from_path(path, options)
+      new(File.read(path), path, options)
+    end
+
+    # @param [Thread::Backtrace::Location] caller_loc
+    # @param [Object] v value to show
+    # @param [bool] with_block whether Temill#show is called with block
+    def add_result(caller_loc, v, with_block)
+      caller_lineno = caller_loc.lineno
+      unless @insertion_points.at_caller_lineno(caller_lineno)
+        @insertion_points.add(make_insertion_point(caller_loc, with_block))
+      end
+      @insertion_points.at_caller_lineno(caller_lineno) << v
+      self
+    end
+
+    def each_source_line(&block)
+      return enum_for(__method__) unless block
+      1.upto(@lines.size-1){| i |
+        block.call(@lines[i], i)
+      }
+    end
+
+    private
+
+    # @param [Thread::Backtrace::Location] caller_loc
+    def make_insertion_point(caller_loc, with_block=false)
+      caller_lineno = caller_loc.lineno
+      last_line = caller_lineno
+      inner_block_range = nil
+      #ParserUtils.add_line_ranges_to_sexp(@sexp) # DEBUG
+      @sexp.deep_each_with_self{| v |
+        if v.kind_of?(Sexp) and
+            [:iter, :call].include?(v.first) and
+            v.line_range.min == caller_lineno
+          last_line = [last_line, v.line_range.max].max
+          if with_block and v.first == :iter and block_sexp = v[3]
+            inner_block_range ||= block_sexp.line_range
+            if inner_block_range.max < block_sexp.line_range.max
+              inner_block_range = v[3].line_range
+            end
+          end
+        end
+      }
+
+      # We don't want to use the caller line to guess the indent level
+      # of the inner body of the block.
+      if inner_block_range
+        if inner_block_range.min == caller_lineno
+          if inner_block_range.max == caller_lineno
+            inner_block_range = nil
+          else
+            inner_block_range = (caller_lineno+1)..(inner_block_range.max)
+          end
+        end
+      end
+
+      if inner_block_range
+        emitter_lineno = inner_block_range.max
+        indent = guess_indent_in_block(inner_block_range)
+      elsif with_block and
+              end_line = @lines[last_line] and
+              /\A\s*(?:end|})\s*$/ =~ end_line
+        emitter_lineno = last_line - 1
+        indent = indent_at(last_line) + @options[:default_indent]
+      else
+        emitter_lineno = last_line
+        indent = indent_at(caller_lineno)
+      end
+
+      InsertionPoint.new(caller_loc, emitter_lineno, with_block, indent)
+    end
+
+    def indent_at(lineno)
+      @lines[lineno][/\A[ \t]*/]
+    end
+
+    def guess_indent_in_block(range)
+      @lines[range].map{| line |
+        line[/\A([ \t]*)\S/] && $1  # remove empty lines
+      }.compact.uniq.sort_by{| indent |
+        indent.gsub(/\t/, ' ' * @options[:tabstop]).size
+      }.first
+    end
+
+
+    # represent a set of insertion points in a single source file
+    class InsertionPointSet
+      include Enumerable
+
+      def initialize
+        @caller_lineno_to_ip = {}
+        @emitter_lineno_to_ips = {}
+      end
+
+      def add(ip)
+        if @caller_lineno_to_ip[ip.caller_lineno]
+          false
+        else
+          @caller_lineno_to_ip[ip.caller_lineno] = ip
+          ((@emitter_lineno_to_ips[ip.emitter_lineno] ||= []) << ip).sort_by!{| ips |
+            ips.caller_lineno
+          }
+          true
+        end
+      end
+
+      # @return [InsertionPoint]
+      # @return [nil]
+      def at_caller_lineno(lineno)
+        @caller_lineno_to_ip[lineno]
+      end
+
+      # @return [Array<InsertionPoint>]
+      # @return [nil]
+      def at_emitter_lineno(lineno)
+        @emitter_lineno_to_ips[lineno]
+      end
+
+      def each(&block)
+        @caller_lineno_to_ip.values.each(&block)
+      end
+    end
+
+    class InsertionPoint
+      attr_reader :caller_loc
+      attr_reader :caller_lineno, :emitter_lineno
+      attr_reader :indent
+      attr_reader :results
+
+      # @param [Thread::Backtrace::Location] caller_loc
+      # @param [Integer] emitter_lineno line number after where to emit results
+      # @param [bool] with_block whether called with block
+      # @param [String] indent
+      def initialize(caller_loc, emitter_lineno, with_block, indent)
+        @caller_location = caller_loc
+        @caller_lineno = caller_loc.lineno
+        @emitter_lineno = emitter_lineno
+        @with_block = with_block
+        @indent = indent
+        @results = []
+      end
+
+      def <<(result)
+        @results << result
+      end
+    end
+  end
+
+  extend TemillImpl
+  include TemillImpl
+
+  _initialize
+end

data/lib/temill/emitter.rb

@@ -0,0 +1,166 @@
+require 'pathname'
+require 'fileutils'
+
+class Temill
+  module Emitters
+    class Base
+      def initialize(options)
+        @options = options
+      end
+
+      # @param [Hash<String, SourceFile>] source_files
+      def execute(source_files)
+      end
+
+      # @param [Array<SourceFile>] source_files
+      def call(source_files)
+        execute(source_files)
+      end
+
+      def emit_for_source_file(sf, out_f)
+        lines_map = [] # map source lineno to output lineno
+        compact_ranges = sf.insertion_points.map{| ip | ip.caller_lineno .. ip.emitter_lineno }
+        printer = Printer.new(out_f, **@options)
+        sf.each_source_line{| line,i |
+          lines_map[i] = printer.lineno
+          printer.print_raw(line) if not @options[:compact] or compact_ranges.any?{| r | r.cover?(i) }
+          if ips = sf.insertion_points.at_emitter_lineno(i)
+            ips.each{| ip |
+              printer.indent = ip.indent
+              printer.print_str(annotation(ip, lines_map[ip.caller_lineno]))
+              ip.results.each{| obj |
+                printer.print(obj)
+              }
+            }
+          end
+        }
+      end
+
+      def annotation(ip, output_line_for_caller)
+        "temill showing #{ip.results.size} results" +
+          " for line #{ip.caller_lineno}" +
+          " (line #{output_line_for_caller} in this output)"
+      end
+    end
+
+    class StdoutEmitter < Base
+      def initialize(io, options)
+        @io = io
+        super(options)
+      end
+
+      def execute(source_files)
+        source_files.each{| sf |
+          puts '#--------------------------------'
+          puts "\##{sf.path}"
+          puts '#--------------------------------'
+          emit_for_source_file(sf, @io)
+        }
+        nil
+      end
+    end
+
+    class StringEmitter < Base
+      def execute(source_files)
+        source_files.map{| sf |
+          sio = StringIO.new('', 'w')
+          emit_for_source_file(sf, sio)
+          [sf.path, sio.string]
+        }.to_h
+      end
+    end
+
+    class DirectoryEmitter < Base
+      def initialize(dir_path, options)
+        @dir_path = Pathname.new(dir_path)
+        super(options)
+      end
+
+      def execute(source_files)
+        FileUtils.makedirs(@dir_path)
+        written = []
+        source_files.each{| sf |
+          fname = output_fname(sf.path, written)
+          File.open(fname, 'w'){| f |
+            emit_for_source_file(sf, f)
+            written << fname
+          }
+        }
+        nil
+      end
+
+      def output_fname(base_fname, written)
+        fname_base = (@dir_path + File.basename(base_fname)).to_s
+        current_fname = fname_base
+        suffix_n = 1
+        while written.include?(current_fname)
+          current_fname = fname_base + ".#{suffix_n}"
+          suffix_n += 1
+        end
+        current_fname
+      end
+    end
+
+    class Printer
+      attr_reader :output_lines
+      attr_accessor :indent
+
+      def initialize(io = $stdout, **options)
+        @options = options
+        @output_lines = 0
+        @indent = ''
+        @io = io
+      end
+
+      def lineno
+        @output_lines + 1
+      end
+
+      def obj_to_s(obj)
+        case f = @options[:inspect]
+        when Symbol
+          obj.__send__(f)
+        when nil
+          obj.pretty_inspect
+        else
+          f.call(obj)
+        end
+      end
+
+      def print(obj)
+        print_str(obj_to_s(obj))
+      end
+
+      def print_str(str)
+        str.each_line{| line |
+          out @indent
+          out '# '
+          out_nl line
+        }
+      end
+
+      def print_empty_line
+        out @indent
+        out_nl '#'
+      end
+
+      def print_raw(str)
+        str.each_line{| line |
+          out_nl line
+        }
+      end
+
+      def out(str)
+        @io.print(str)
+        self
+      end
+
+      def out_nl(str=nil)
+        @io.puts(str)
+        @output_lines += 1
+        self
+      end
+    end
+
+  end
+end

data/lib/temill/parser.rb

@@ -0,0 +1,140 @@
+require 'ruby_parser'
+
+class Temill
+  ParserResult = Struct.new(:value, :line_range, :sym)
+
+  # Override parser and scanner actions since we need the range of
+  # each expr in Ruby programs
+  module ParserHack
+    def before_reduce(val, *rest)
+      #ap val
+      val.map{| v |
+        if v.kind_of?(ParserResult)
+          v.value
+        else
+          v
+        end
+      }
+    end
+
+    def after_reduce(val, _values, result)
+      min = max = nil
+      #debug_print_state_stack
+      val.each{| v |
+        if v.kind_of?(ParserResult) and v.sym != :tNL
+          min = [min, v.line_range.min].compact.min
+          max = [max, v.line_range.max].compact.max
+        end
+      }
+
+      if result.kind_of?(Sexp)
+        result.line_range = min..max
+      end
+      # sym is not specified, but OK as long as it is used to check whether
+      # the symbol is newline or not.
+      ParserResult.new(result, min..max, nil)
+    end
+
+    # wrap the value of each token to ParserResult
+    def next_token
+      sym,val = super
+      lineno = lexer.lineno
+      [sym, ParserResult.new(val, lineno..lineno, sym)]
+    end
+
+    def debug_print_state_stack
+      if @racc_tstack
+        pp @racc_tstack.zip(@racc_vstack).map{| tok,v |
+          [token_to_str(tok), v]
+        }
+      end
+    end
+  end
+
+  module RaccHack
+
+    # override all actions and make them call before_reduce/after_reduce
+    # before/after each action is executed
+    def self.included(klass)
+      #racc_action_table,
+      #racc_action_check,
+      #racc_action_default,
+      #racc_action_pointer,
+      #racc_goto_table,
+      #racc_goto_check,
+      #racc_goto_default,
+      #racc_goto_pointer,
+      #racc_nt_base,
+      #racc_reduce_table,
+      #racc_token_table,
+      #racc_shift_n,
+      #racc_reduce_n,
+      #racc_use_result_var = klass::Racc_arg
+
+      racc_reduce_table = klass::Racc_arg[9]
+
+      racc_reduce_table.each_slice(3).map{| _,_,method_name |
+        method_name
+      }.uniq.each{| method_name |
+        begin
+          method = klass.instance_method(method_name)
+        rescue NameError
+          next
+        end
+        method.tap{| original_umethod |
+          klass.__send__(:define_method, method_name){| val,_values,result |
+            new_val = before_reduce(val, _values, result)
+            new_result = original_umethod.bind(self).call(new_val, _values, result)
+            after_reduce(val, _values, new_result)
+          }
+        }
+      }
+    end
+
+    # should return new val
+    def before_reduce(val, _values, result)
+      val
+    end
+
+    # should return new result
+    #
+    # Note that val is equal to the object passed to before_reduce,
+    # not new val returned by before_reduce
+    def after_reduce(val, _values, result)
+      result
+    end
+  end
+
+  module ParserUtils
+    module_function
+
+    def add_line_ranges_to_sexp(sexp)
+      if sexp.kind_of?(Sexp)
+        sexp.each{| elt |
+          add_line_ranges_to_sexp(elt)
+        }
+        sexp << sexp.line_range
+      end
+      sexp
+    end
+  end
+
+  # XXX: only Ruby23Parser is supported
+  class Ruby23Parser < ::Ruby23Parser
+    include RaccHack
+    prepend ParserHack
+  end
+end
+
+class Sexp
+  attr_accessor :line_range
+
+  # same as deep_each, but pass self first
+  def deep_each_with_self(&block)
+    return enum_for(__method__) unless block
+
+    block.call(self)
+    deep_each(&block)
+  end
+end
+

data/lib/temill/version.rb

@@ -0,0 +1,3 @@
+class Temill
+  VERSION = "0.1.0"
+end

data/lib/temill.rb

@@ -0,0 +1,18 @@
+# FIXME:
+# with cparser,
+#   Temill.show(
+#     55
+#   )
+# results in
+#   Temill.show(
+#     55
+#   # temill showing 1 results for line 1 (line 1 in this output)
+#   # 55
+#   )
+# ,which is not what we want.
+Racc_No_Extensions = true
+
+require "temill/version"
+require 'temill/core'
+require 'temill/parser'
+require 'temill/emitter'

data/temill.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'temill/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "temill"
+  spec.version       = Temill::VERSION
+  spec.authors       = ["Yusuke Takeuchi"]
+  spec.email         = ["v.takeuchi+gh@gmail.com"]
+
+  spec.summary       = %q{Temill shows objects in embedded comments in source files.}
+  spec.description   = spec.summary
+  spec.homepage      = "https://github.com/YusukeTakeuchi/temill"
+  spec.license       = "MIT"
+
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = '>= 2.3'
+
+  spec.add_dependency 'ruby_parser', '~> 3.8'
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency 'awesome_print', '~> 1.7'
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: temill
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yusuke Takeuchi
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-11-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby_parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+description: Temill shows objects in embedded comments in source files.
+email:
+- v.takeuchi+gh@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/temill.rb
+- lib/temill/core.rb
+- lib/temill/emitter.rb
+- lib/temill/parser.rb
+- lib/temill/version.rb
+- temill.gemspec
+homepage: https://github.com/YusukeTakeuchi/temill
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Temill shows objects in embedded comments in source files.
+test_files: []