exa 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f27cfd470e0649009f1628ac416129e508b9f892
+  data.tar.gz: de0b8c876be5db9d1aa5e51f139f675d0fef6fbf
+SHA512:
+  metadata.gz: 84260a3a82086953e2e99ff908f370609ddbe5a60bf7567f646939ae71137477c7e00b5c29359d8339a458c1cb527dbc1bc14c891b376604c4a5bd78e2bb0737
+  data.tar.gz: 85cca81bd881342d01aa2878127d9469a1f154258285dcefd43794f1b948fdc8398e20a0d3c44d780b3b9069ecf9792842b75491ce43ae655c9337568096b9db

data/.document

@@ -0,0 +1,3 @@
+- 
+ChangeLog.md
+LICENSE.txt

data/.gitignore

@@ -0,0 +1,6 @@
+/.bundle
+/.yardoc/
+/Gemfile.lock
+/doc/
+/pkg/
+/vendor/cache/*.gem

data/.rspec

@@ -0,0 +1 @@
+--colour --format documentation

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown --title "exa Documentation" --protected

data/ChangeLog.md

@@ -0,0 +1,4 @@
+### 0.1.0 / 2016-12-20
+
+* Initial release:
+

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'pastel'
+
+group :development do
+  gem 'kramdown'
+  gem 'pry'
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2016 Joseph Weissman
+
+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,33 @@
+# exa
+
+* [Homepage](https://rubygems.org/gems/exa)
+* [Documentation](http://rubydoc.info/gems/exa/frames)
+* [Email](mailto:jweissman1986 at gmail.com)
+
+[![Code Climate GPA](https://codeclimate.com/github//exa/badges/gpa.svg)](https://codeclimate.com/github//exa)
+
+## Description
+
+TODO: Description
+
+## Features
+
+## Examples
+
+    require 'exa'
+
+## Requirements
+
+## Install
+
+    $ gem install exa
+
+## Synopsis
+
+    $ exa
+
+## Copyright
+
+Copyright (c) 2016 Joseph Weissman
+
+See {file:LICENSE.txt} for details.

data/Rakefile

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'rubygems'
+
+begin
+  require 'bundler/setup'
+rescue LoadError => e
+  abort e.message
+end
+
+require 'rake'
+
+
+require 'rubygems/tasks'
+Gem::Tasks.new
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+task :test    => :spec
+task :default => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new  
+task :doc => :yard
+
+require 'cucumber/rake/task'
+
+Cucumber::Rake::Task.new do |t|
+  t.cucumber_opts = %w[--format pretty]
+end

data/bin/exa

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+root = File.expand_path(File.join(File.dirname(__FILE__),'..'))
+if File.directory?(File.join(root,'.git'))
+  Dir.chdir(root) do
+    begin
+      require 'bundler/setup'
+      require 'exa'
+      require 'exa/shell'
+
+      Exa::Shell.repl! do |config|
+        config.prompt = -> shell {  shell.pastel.bold(" #{shell.pwd.path} $ ") }
+      end
+    rescue LoadError => e
+      warn e.message
+      warn "Run `gem install bundler` to install Bundler"
+      exit(-1)
+    end
+  end
+end

data/exa.gemspec

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+require 'yaml'
+
+Gem::Specification.new do |gem|
+  gemspec = YAML.load_file('gemspec.yml')
+
+  gem.name    = gemspec.fetch('name')
+  gem.version = gemspec.fetch('version') do
+                  lib_dir = File.join(File.dirname(__FILE__),'lib')
+                  $LOAD_PATH << lib_dir unless $LOAD_PATH.include?(lib_dir)
+
+                  require 'exa/version'
+                  Exa::VERSION
+                end
+
+  gem.summary     = gemspec['summary']
+  gem.description = gemspec['description']
+  gem.licenses    = Array(gemspec['license'])
+  gem.authors     = Array(gemspec['authors'])
+  gem.email       = gemspec['email']
+  gem.homepage    = gemspec['homepage']
+
+  glob = lambda { |patterns| gem.files & Dir[*patterns] }
+
+  gem.files = `git ls-files`.split($/)
+  gem.files = glob[gemspec['files']] if gemspec['files']
+
+  gem.executables = gemspec.fetch('executables') do
+    glob['bin/*'].map { |path| File.basename(path) }
+  end
+  gem.default_executable = gem.executables.first if Gem::VERSION < '1.7.'
+
+  gem.extensions       = glob[gemspec['extensions'] || 'ext/**/extconf.rb']
+  gem.test_files       = glob[gemspec['test_files'] || '{test/{**/}*_test.rb']
+  gem.extra_rdoc_files = glob[gemspec['extra_doc_files'] || '*.{txt,md}']
+
+  gem.require_paths = Array(gemspec.fetch('require_paths') {
+    %w[ext lib].select { |dir| File.directory?(dir) }
+  })
+
+  gem.requirements              = Array(gemspec['requirements'])
+  gem.required_ruby_version     = gemspec['required_ruby_version']
+  gem.required_rubygems_version = gemspec['required_rubygems_version']
+  gem.post_install_message      = gemspec['post_install_message']
+
+  split = lambda { |string| string.split(/,\s*/) }
+
+  if gemspec['dependencies']
+    gemspec['dependencies'].each do |name,versions|
+      gem.add_dependency(name,split[versions])
+    end
+  end
+
+  if gemspec['development_dependencies']
+    gemspec['development_dependencies'].each do |name,versions|
+      gem.add_development_dependency(name,split[versions])
+    end
+  end
+end

data/features/exa.feature

@@ -0,0 +1 @@
+Feature: Blah blah blah

data/features/step_definitions/exa_steps.rb

@@ -0,0 +1 @@
+@wip

data/gemspec.yml

@@ -0,0 +1,16 @@
+name: exa
+summary: "recursive in-memory algos and data structures"
+description: "recursive in-memory structures"
+license: MIT
+authors: Joseph Weissman
+email: jweissman1986@gmail.com
+homepage: https://rubygems.org/gems/exa
+
+development_dependencies:
+  bundler: ~> 1.10
+  codeclimate-test-reporter: ~> 0.1
+  cucumber: ~> 0.10.2
+  rake: ~> 10.0
+  rspec: ~> 3.0
+  rubygems-tasks: ~> 0.2
+  yard: ~> 0.8

data/lib/exa.rb

@@ -0,0 +1,85 @@
+require 'exa/version'
+require 'exa/tree_node'
+require 'exa/visitor'
+
+module Exa
+  class Process
+    def initialize(title)
+      @title = title
+    end
+
+    def register
+      Process.table += [ self ]
+    end
+
+    def unregister
+      Process.table -= [ self ]
+    end
+
+    def run!
+      register
+      perform!
+      unregister
+    end
+
+    def self.table
+      @table ||= []
+    end
+  end
+
+  class Copier < Process
+    def initialize(source, target)
+      @source = source
+      @target = target
+      super("copy #{source} -> #{target}")
+    end
+
+    def perform!
+      @target.update @source.value
+    end
+  end
+
+  class Deleter < Process
+    def initialize(target)
+      @target = target
+      super("delete #{target}")
+    end
+
+    def perform!
+      @target.parent.remove_child(child_name: @target.name)
+    end
+  end
+
+  class << self
+    def remember(path, value)
+      p [ :remember, path: path, value: value ]
+      recall(path).update(value)
+    end
+    alias :[]= :remember
+
+    def recall(path)
+      p [ :recall, path: path ]
+      visitor.seek(path)
+    end
+    alias :[] :recall
+
+    def expand(path)
+      visitor.query(path)
+    end
+    alias :call :expand
+
+    def clean_slate!
+      @root = TreeNode.new(name: '', value: '(root)')
+      # @visitor = Visitor.new(@root)
+    end
+
+    private
+    def visitor
+      Visitor.new(root)
+    end
+
+    def root
+      @root ||= TreeNode.new(name: '', value: '(system root)')
+    end
+  end
+end

data/lib/exa/shell.rb

@@ -0,0 +1,107 @@
+require 'pry'
+require 'pastel'
+
+module Exa
+  class ShellConfig
+    attr_accessor :prompt
+  end
+
+  class ShellCommand
+    def initialize(title:,args:)
+      @title = title
+      @args = args
+    end
+
+    def evaluate(shell)
+      case @title
+      when "ls" then
+        if shell.pwd.children.any?
+          shell.print_collection shell.pwd.children.map(&:name)
+        else
+          shell.print_warning "(no children of #{shell.pwd.path})"
+        end
+      when "cd" then
+        target = Exa.expand(@args.first)
+        if target && !target.empty?
+          shell.change_directory target.first
+        else
+          shell.print_warning "Invalid path for cd: #{@args.first}"
+        end
+      when "mkdir" then
+        target = Exa.recall(@args.first)
+      when "pwd" then
+        shell.print_info shell.pwd.path
+      else
+        shell.print_warning "Unknown command: '#@title'"
+      end
+    end
+
+    def self.extract(string)
+      tokens = string.split(' ')
+      # p [ :extract, tokens: tokens ]
+      cmd,*args = *tokens
+      # p [ :extract, cmd: cmd, args: args ]
+      new(title: cmd, args: args)
+    end
+  end
+
+  class Shell
+    attr_reader :pwd
+
+    def initialize(pwd)
+      @pwd = pwd
+    end
+
+    def configuration
+      @config ||= ShellConfig.new
+    end
+
+    def kickstart!
+      loop do
+        print configuration.prompt.call(self)
+        inp = gets.chomp
+        outp = shell_eval(inp)
+        p outp unless outp.nil? || (outp.respond_to?(:empty?) && outp.empty?)
+      end
+    end
+
+    def shell_eval(cmd_str)
+      cmd = ShellCommand.extract(cmd_str)
+      cmd.evaluate(self)
+    end
+
+    def change_directory(target)
+      @pwd = target
+    end
+
+    def print_collection(elements)
+      puts
+      elements.each do |element|
+        puts " - " + pastel.blue("  #{element}")
+      end
+      puts
+    end
+
+    def print_warning(message)
+      puts
+      puts pastel.red(message)
+      puts
+    end
+
+    def print_info(message)
+      puts
+      puts pastel.green(message)
+      puts
+    end
+
+    def pastel
+      @pastel ||= Pastel.new
+    end
+
+    def self.repl!
+      shell = new(Exa['/'])
+      yield shell.configuration
+      shell.kickstart!
+    end
+  end
+end

data/lib/exa/tree_node.rb

@@ -0,0 +1,159 @@
+module Exa
+  class TreeNode
+    attr_reader :name, :parent, :overlays, :links
+    def initialize(name:, value: nil, parent: nil, virtual: false, symbolic: false)
+      p [ :tree_node, name: name ]
+      @name = name
+      @value = value
+      @parent = parent
+      @virtual = virtual
+      @symbolic = symbolic
+      @children = []
+      @overlays = []
+      @links = []
+    end
+
+    def value
+      if virtual?
+        constituents.first.value
+      elsif symbolic?
+        dereference_symbolic_link.value
+      else
+        @value
+      end
+    end
+
+    def virtual?
+      @virtual
+    end
+
+    def symbolic?
+      @symbolic
+    end
+
+    def inspect
+      "<#{@name}>"
+    end
+
+    def path
+      if symbolic?
+        dereference_symbolic_link.path
+      else
+        if @parent
+          slash_name = "/#@name"
+          if @parent.path == '/'
+            slash_name
+          else
+            @parent.path + slash_name
+          end
+        else
+          '/' #@name
+        end
+      end
+    end
+
+    def update(val)
+      @value = val
+      self
+    end
+
+    def create_child(child_name:)
+      child = TreeNode.new(name: child_name, parent: self)
+      @children << child
+      child
+    end
+
+    def remove_child(child_name:)
+      child = @children.detect { |c| c.name == child_name }
+      @children.delete(child)
+      self
+    end
+
+    def unify(overlay:)
+      if overlay.virtual?
+        raise "Won't union mount virtual paths! (Try `link(source: ...)` instead.)"
+      end
+
+      @overlays << overlay
+      self
+    end
+
+    def link(source:)
+      @links << source
+      self
+    end
+
+    def children
+      if virtual?
+        virtualize(constituents.flat_map(&:children))
+      else
+        @children + symbolize(symbolic_children) + virtualize(virtual_children)
+      end
+    end
+
+    def recall(path)
+      Visitor.new(self).seek(path)
+    end
+    alias :[] :recall
+
+    def query(path)
+      Visitor.new(self).query(path)
+    end
+
+    def copy(target)
+      Copier.new(self, target).perform!
+    end
+
+    def delete
+      Deleter.new(self).perform!
+    end
+
+    protected
+    def constituents
+      sources = if parent.virtual?
+                  parent.constituents.flat_map(&:children)
+                else
+                  parent.overlays.flat_map(&:children)
+                end
+
+      sources.select do |candidate|
+        candidate.name == @name
+      end
+    end
+
+    def virtual_children
+      @overlays.flat_map(&:children)
+    end
+
+    def symbolic_children
+      # this is really a reference
+      @links.flat_map(&:children)
+    end
+
+    def dereference_symbolic_link
+      # okay, we're symbolic... so our parents created us
+      # and have a link
+      parent.links.flat_map(&:children).detect do |linked_child|
+        linked_child.name == @name
+      end
+    end
+
+    private
+    def symbolize(schildren)
+      schildren.map(&method(:symbolize_one))
+    end
+
+    def symbolize_one(schild)
+      TreeNode.new(name: schild.name, value: schild.value, parent: self, symbolic: true)
+    end
+
+    def virtualize(vchildren)
+      vchildren.map(&method(:virtualize_one))
+    end
+
+    def virtualize_one(vchild)
+      TreeNode.new(name: vchild.name, value: vchild.value, parent: self, virtual: true)
+    end
+  end
+end
+

data/lib/exa/version.rb

@@ -0,0 +1,4 @@
+module Exa
+  # exa version
+  VERSION = "0.1.0"
+end

data/lib/exa/visitor.rb

@@ -0,0 +1,100 @@
+module Exa
+  class Visitor
+    def initialize(root)
+      @root = root
+    end
+
+    def gather_leaves(branch=@root, depth: 10)
+      return [] if depth < 0
+      if branch.children.any?
+        branch.children.flat_map do |child|
+          gather_leaves(child, depth: depth-1)
+        end.uniq
+      else # we are a leaf!
+        [ branch ]
+      end
+    end
+
+    def gather_branches(branch=@root, depth: 10)
+      return [] if depth < 0
+      if branch.children.any?
+        [ branch ] + branch.children.flat_map do |child|
+          gather_branches(child, depth: depth-1)
+        end.uniq
+      else # we are a leaf!
+        [ ]
+      end
+    end
+
+    def seek(path, create_missing: true)
+      path = '/' + path unless path.start_with?('/')
+      _root, *path_segments = path.split('/')
+      current = @root
+      path_segments.each do |segment|
+        next_child = current.children.detect do |child|
+          child.name == segment
+        end
+
+        current = if next_child
+          next_child
+        else
+          return nil unless create_missing
+          current.create_child(child_name: segment)
+        end
+      end
+      current
+    end
+
+    def query(path)
+      path = '/' + path unless path.start_with?('/')
+      _root, next_segment, *remaining_segments = path.split('/')
+      remaining_path = '/' + remaining_segments.join('/')
+      current = @root
+      return [current] unless next_segment
+      if next_segment == '*'
+        # need to multiplex remaining query across *all* children
+        next_children = current.children
+        if remaining_segments.any?
+          next_children.flat_map do |child|
+            child.query(remaining_path).uniq
+          end
+        else
+          next_children
+        end
+      elsif next_segment == '**'
+        # this is more subtle, and really points to:
+        # do we need to be treating the path query as a regular expression?
+        # and matching against *all* filenames?
+        if remaining_segments.any?
+          gather_branches(current).flat_map do |folder|
+            folder.query(remaining_path).uniq
+          end
+        else
+          gather_leaves(current)
+        end
+      elsif next_segment == '..'
+        # need to back up...
+        parent = current.parent
+        if remaining_segments.any?
+          parent.children.flat_map do |child|
+            child.query(remaining_path).uniq
+          end.uniq
+        else
+          [ parent ]
+        end
+      else
+        # need to find just child matching *this* segment
+        next_child = current.children.detect { |c| c.name == next_segment }
+        if next_child
+          if remaining_segments.any?
+            next_child.query(remaining_path).uniq
+          else
+            [ next_child ]
+          end
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/spec/exa_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+require 'pry'
+require 'exa'
+
+describe Exa do
+  before do
+    Exa.clean_slate!
+  end
+
+  it 'should store a value' do
+    Exa.remember('x', 5)
+    Exa.remember('y', 7)
+    expect(Exa.recall('x').value).to eq(5)
+    expect(Exa.recall('y').value).to eq(7)
+  end
+
+  it 'has shorthand' do
+    Exa['hi'] = 'hello'
+    expect( Exa['hi'].value ).to eq('hello')
+  end
+
+  it 'should store a structured value' do
+    Exa.remember('/hello/world', 5)
+    expect(Exa.recall('/hello/world').value).to eq(5)
+
+    # shorthand
+    expect(Exa['/hello/world'].value).to eq(5)
+  end
+
+  it 'should navigate' do
+    Exa.remember("/a/b/c", 'd')
+    expect(Exa["/a/b/c"].value).to eq('d')
+    expect(Exa["/a/b/c"].path).to eq('/a/b/c')
+    expect(Exa["/a"].children).to eq([Exa["/a/b"]])
+    expect(Exa["/a"].parent).to eq(Exa["/"])
+
+    expect(Exa['/'].path).to eq('/')
+  end
+
+  describe 'filesystem-like structures' do
+    before do
+      Exa["/usr/joe/minutes/alpha"] = "hello"
+      Exa["/usr/joe/books/ch01/sec01/intro"] = "welcome"
+      Exa["/usr/mal/minutes/beta"] = "world"
+    end
+
+    it 'should unify/virtualize' do
+      Exa["/usr/mal/friends"].unify(overlay: Exa["/usr/joe"])
+
+      expect( Exa["/usr/mal/friends/minutes"] ).to be_virtual
+      expect( Exa["/usr/mal/friends/minutes/alpha"] ).to be_virtual
+      expect( Exa["/usr/mal/friends/minutes/alpha"].value ).to eq('hello')
+      expect( Exa["/usr/mal/friends/books/ch01/sec01/intro"].value ).to eq('welcome')
+    end
+
+    it 'should symlink' do
+      # okay, make a union mount so we have virtual paths...
+      Exa["/usr/joe/friends"].unify(overlay: Exa["/usr/mal"])
+
+      expect( Exa['/usr/joe/friends/minutes'] ).to be_virtual
+
+      # we should be able to *symlink* to virtual paths
+      # which we can't otherwise mount directly (since virtual)
+      Exa['/news'].link(source: Exa['/usr/joe/friends/minutes'])
+
+      expect( Exa['/news/beta'] ).to be_symbolic
+      expect( Exa['/news/beta'].value ).to eq('world')
+      expect( Exa['/news/beta'].path ).to eq('/usr/joe/friends/minutes/beta')
+    end
+
+    describe 'path expansion' do
+      it 'should expand root path' do
+        expect( Exa.expand('/') ).to eq([ Exa['/'] ])
+      end
+
+      it 'should expand user path without a slash' do
+        expect( Exa.expand('usr')).to eq([ Exa['/usr'] ])
+      end
+
+      it 'should expand double stars' do
+        expect( Exa.expand('**/joe') ).to eq([ Exa['/usr/joe'] ])
+      end
+
+      it 'should expand single stars' do
+        expect( Exa.expand('/usr/*') ).to eq([ Exa['/usr/joe'], Exa['/usr/mal'] ])
+      end
+
+      it 'should expand nested single stars' do
+        expect( Exa.expand('/usr/joe/*/*') ).to eq([ Exa['/usr/joe/minutes/alpha'], Exa['/usr/joe/books/ch01'] ])
+      end
+
+      it 'should expand double dots' do
+        expect( Exa.expand('/usr/..') ).to eq([ Exa['/'] ])
+        expect( Exa.expand('/usr/joe/..') ).to eq([ Exa['/usr'] ])
+      end
+
+      it 'should not find expansions for inexistent paths' do
+        expect( Exa.expand('/does_not_exist') ).to eq([])
+        expect( Exa.expand('/also/does/not/exist') ).to eq([])
+      end
+    end
+
+    it 'should create/nav arbitrary structures' do
+      abel_route = '/universes/ea/regions/blessed_isles/cities/numenor/people/abel'
+      cain_route = '/universes/ea/regions/blessed_isles/cities/numenor/people/cain'
+      Exa[abel_route] = 'hi from abel!'
+      Exa[cain_route] = 'hi from cain!'
+      expect( Exa.expand('/**/people/*') ).to eq([ Exa[abel_route], Exa[cain_route] ])
+    end
+
+    it 'should perform some fs-like operations' do
+      Exa['/tmp/hello'] = 'world'
+
+      Exa['/tmp/hello'].copy(Exa['/tmp/there'])
+      Exa['/tmp/hello'].delete
+
+      expect( Exa['/tmp/there'].value ).to eq('world')
+      expect( Exa['/tmp/hello'].value ).to eq(nil)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'rspec'
+require 'exa/version'
+
+include Exa

metadata

@@ -0,0 +1,168 @@
+--- !ruby/object:Gem::Specification
+name: exa
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Joseph Weissman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.2
+- !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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubygems-tasks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: recursive in-memory structures
+email: jweissman1986@gmail.com
+executables:
+- exa
+extensions: []
+extra_rdoc_files:
+- ChangeLog.md
+- LICENSE.txt
+- README.md
+files:
+- ".document"
+- ".gitignore"
+- ".rspec"
+- ".yardopts"
+- ChangeLog.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/exa
+- exa.gemspec
+- features/.gitkeep
+- features/exa.feature
+- features/step_definitions/.gitkeep
+- features/step_definitions/exa_steps.rb
+- gemspec.yml
+- lib/exa.rb
+- lib/exa/shell.rb
+- lib/exa/tree_node.rb
+- lib/exa/version.rb
+- lib/exa/visitor.rb
+- spec/exa_spec.rb
+- spec/spec_helper.rb
+homepage: https://rubygems.org/gems/exa
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+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: recursive in-memory algos and data structures
+test_files: []