treeline 0.1.0

data/.gitignore

@@ -0,0 +1 @@
+/pkg/

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# gem's dependencies are specified in treeline.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,14 @@
+PATH
+  remote: .
+  specs:
+    treeline (0.1.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  treeline!

data/LICENSE.md

@@ -0,0 +1,158 @@
+The Don't Be a Dick License
+===========================
+_version 0.1_
+
+**Project:** [Treeline](http://github.com/CraigCottingham/treeline) v0.1  
+**Author:** Craig S. Cottingham (<craig.cottingham@gmail.com>)
+
+The purpose of this license is to permit the broadest feasible scope for reuse and modification of creative work,
+restricted only by the requirement that one is not a dick about it.
+
+1. Legal Parameters
+-------------------
+For legal purposes, the DBAD license is a superset of the [Apache License, Version 2.0][1] and incorporates all
+terms, conditions, privileges and limitations therein. The following text is a binding part of this license for
+this project:
+
+> Copyright 2011 Craig S. Cottingham
+
+> Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+>   <http://www.apache.org/licenses/LICENSE-2.0>
+
+> Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+  
+Nothing in the following text should be construed to inhibit, contradict, or override any part of the Apache
+License, Version 2.0.  
+
+2. Definitions
+--------------
+The following terms and definitions shall be in effect for the rest of this document.
+
+>  **NOTE:** Singular nouns and pronouns are used throughout this License for 
+  grammatical convenience.  However, any of the terms below _may_ refer to a
+  collective work or group of people.  If this pegs your punctiliousness, you
+  are directed to mentally substitute "Person _or persons_," "Dick _or 
+  dicks,_" etc., throughout this license.  Just don't tell us about it.
+
+### A. Project
+
+A creative work of (software | writing | visual art | music) into which significant time and energy have been
+invested by people who _are not you,_ and which has been released into the world for the benefit of the general
+public (_including you._)
+
+The **Project** may include, incorporate, derive from, or be inspired by other works.  The Author, being a
+Reasonable Person, has made use of such source materials only as permitted by their own licenses or applicable
+law. The License you are reading applies only to those portions of the Project which are original and distinct to
+it. Source materials may be covered by their own licenses or conditions, and should not be assumed to have
+coverage under this License. (However, you are strongly encouraged not to be a dick about them either.)
+
+### B. Author
+
+A person who has invested significant time and energy into the Project licensed herein. Given the Author's
+release of the Project to the world under a liberal license, the Author is declared a Reasonable Person (at least
+within this context) and inherits all attributes, freedoms, and responsibilities thereof. No other assumptions
+are made about the Author, nor should you make any.
+
+### C. Reasonable Person
+
+A person who respects the time and energy that have been invested in the Project licensed herein, and acts
+accordingly.  A Reasonable Person is broadly characterized as one who exercises his or her privilege to use,
+_not_ use, redistribute, modify, improve, worsen, review, report issues upon, participate in the community of,
+or ignore the work _without_ placing undue demands upon the Author.  I.e., a Reasonable Person is a constituent
+of the majority of open source users and the population at large who are not Dicks.
+
+### D. Dick
+
+A person who _does not_ respect the time and energy that have been invested in the Project, and acts to punish
+such effort by giving others associated with the Project -- including, but not limited to, the Author -- a hard
+time.  A Dick is nearly always selfish, but not necessarily with deliberate intent; some Dicks are merely
+thoughtless.  The distinguishing characteristic of a Dick is that he or she places burdens upon Reasonable People,
+reducing their motivation to engage in open source activities.  This damping effect is a significant detriment to
+the Project, to open source in general, to the production of new intellectual value in the world -- and,
+ultimately, to the Dick himself or herself.
+
+>  **NOTE:** Despite its original gender association, the word "Dick" is used herein in a _cultural_ context
+and not a _genital_ context.  This License has chosen to adopt the term for its linguistic force and psychological
+impact, and sincerely regrets any inference of sexism.  For purposes of the terms and conditions contained herein,
+it is understood that both men and women are equally capable of being Dicks.  
+  
+>  (But they shouldn't be.)  
+  
+3. Permissions
+--------------
+
+The following privileges are granted explicitly and exclusively to Reasonable People.  Although the Author
+acknowledges the practical unfeasibility of barring Dicks from enjoying the same privileges, they are nevertheless
+asked to refrain from any activity related to the Project _and/or_ to reconsider their behavior and stop
+being Dicks.
+
+1. You are permitted to use the Project or any component of the Project.
+
+2. You are permitted to redistribute the Project or any component of the Project, by itself or as part of a
+different work, provided that you give fair and reasonable credit back to the Author.
+
+3. You are permitted to change the Project for your own needs or anyone else's.  You may keep your changes to
+yourself or submit them back to the Author or the community, as you see fit, provided you are not a Dick about it.
+
+4. You are permitted and encouraged to participate in any community related to the Project, or to create new
+communities.
+
+5. You are permitted to report issues or problems with the Project, and to request that they be addressed,
+so long as the request is made in a reasonable fashion.  (This privilege does _not_ oblige the Author to respond.)
+
+6. You are permitted to make money from the Project.  No recompense is owed to the Author unless by separate
+agreement, although sharing opportunities for mutual benefit is by no means discouraged.
+
+7. You are permitted to discuss the Project in any medium, in any positive or negative spirit, so long as
+criticism is not libelous nor _ad hominem._  (I.e., don't lie, and keep it about the _work_ and not the _people._)
+
+8. You are permitted to ignore the Project completely and make no use of it whatsoever.  This right is
+irrevocable and absolute, and extended to Dicks and Reasonable People alike.
+
+4. Limitations
+--------------
+
+The following restrictions are imposed explicitly and exclusively upon Dicks.  These limitations are the inverse
+of the above privileges and are also tautological, as the prohibited actions are those _definitive_ of Dickhood.
+
+1. You may not impede Reasonable People from exercising their privilege to use, redistribute, change, participate
+in, profit from, discuss, or ignore the Project.
+
+2. You may not withhold the Author's credit for the Project, nor otherwise present the work of anyone else as
+your own.
+
+3. You may not hold the Author responsible for any use or abuse of the Project by you or anyone else.
+
+4. You may not troll, flame, nor dumb down any community associated with the Project.
+
+5. Barring separate agreements, you may not _demand_ any time or attention on the part of the Author nor anyone
+else in the community.  You may not hold the Author personally accountable for any issues you discover nor
+otherwise spread your own problems to other people.
+
+6. You may not attempt to _compel_ time nor money from the Author nor any other community member by any means,
+including but not limited to legal action, intimidation, or annoyance.  
+
+7. You may not engage in _ad hominem_ (i.e. personal) attacks or criticism of the Author in the course of
+criticizing the Project.
+
+8. You may not impede the absolute and irrevocable privilege of the Author and other members of the community
+to ignore you.  
+
+5. Contact
+----------
+For more information about this Project, contact the Author at:
+
+* Craig S. Cottingham - <craig.cottingham@gmail.com>
+
+For more information about the DBAD License, contact the Author, or the originator of the License at:
+
+* Stephen Eley - <sfeley@gmail.com>
+
+[1]: http://apache.org/licenses/LICENSE-2.0

data/README.md

@@ -0,0 +1,91 @@
+# Treeline
+
+Treeline turns indented-line input into a tree structure.
+
+Given a sequence of lines with varying levels of indentation, like this:
+
+    line 1
+      line 2
+      line 3
+        line 4
+      line 5
+      
+Treeline will produce a hash like this:
+
+    {
+      "line 1" => {
+        "line 2" => {},
+        "line 3" => {
+          "line 4" => {},
+        },
+        "line 5" => {},
+      },
+    }
+
+## Installation
+
+    $ gem install treeline
+
+## Usage
+
+The `parse` method on `Treeline::Parser` does the heavy lifting.
+
+    parser = Treeline::Parser.new
+    tree = parser.parse lines
+    
+The parser is bone-headed simple. The first line of input is taken to be the root of a new tree.
+For each subsequent line, the amount of indentation is compared to the amount in the previous line, and
+
+* if the indentation is the same, the new line is added as a sibling of the previous;
+* if the indentation is greater, the new line is added as a child of the previous; or
+* if the indentation is less, the parser climbs back towards the root until one of the previous
+  two rules applies.
+
+`parse` optionally takes a block. Each line of the input will be passed to the block, which should
+return the line modified as desired. For instance, to force all of the text to lowercase:
+
+    parser = Treeline::Parser.new
+    tree = parser.parse(lines) do | line |
+      line.downcase
+    end
+    
+The block is called *before* the amount of indentation is determined, so you can change the indentation
+if you want to.
+    
+## Dependencies
+
+None at the moment.
+
+## Support
+
+Wiki: <https://github.com/CraigCottingham/treeline/wiki>
+
+## To do
+
+Some things I'm considering adding:
+
+* Allow the first line to have leading whitespace, and strip that amount of whitespace from each
+  subsequent line
+  
+## Contributing
+
+Treeline has been written the particular need I have *right now* in mind. I'm trying hard not to bulk it up
+with stuff that I or someone else might want someday. That being said, if you have a particular need that
+Treeline doesn't quite satisfy in its current state, I'm happy to consider requests or (better yet)
+contributions.
+
+Here’s the most direct way to get your work merged into the project:
+
+1. Fork the project.
+2. Clone down your fork ( git clone git://github.com/<username>/treeline.git ).
+3. Create a topic branch to contain your change ( git checkout -b my_awesome_feature ).
+4. Hack away, add tests. Not necessarily in that order.
+5. Make sure everything still passes by running `rake test`.
+6. If necessary, rebase your commits into logical chunks, without errors.
+7. Push the branch up ( git push origin my_awesome_feature ).
+8. Send a pull request.
+
+## License
+
+Copyright &copy; 2011 Craig S. Cottingham.
+It is free software, and may be redistributed under the terms specified in the LICENSE file.

data/Rakefile

@@ -0,0 +1,41 @@
+require 'bundler'
+require 'rake'
+require 'rake/testtask'
+require File.expand_path('../lib/treeline/version', __FILE__)
+
+Bundler::GemHelper.install_tasks
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+end
+
+# namespace :test do
+#   Rake::TestTask.new(:lint) do |test|
+#     test.libs << 'lib' << 'test'
+#     test.pattern = 'test/test_active_model_lint.rb'
+#   end
+# 
+#   task :all => ['test', 'test:lint']
+# end
+
+# task :default => 'test:all'
+task :default => 'test'
+
+desc 'Builds the gem'
+task :build do
+  sh "gem build treeline.gemspec"
+end
+
+desc 'Builds and installs the gem'
+task :install => :build do
+  sh "gem install pkg/treeline-#{Treeline::VERSION}.gem"
+end
+
+desc 'Tags version, pushes to remote, and pushes gem'
+task :release => :build do
+  sh "git tag v#{Treeline::VERSION}"
+  sh "git push origin master"
+  sh "git push origin v#{Treeline::VERSION}"
+  sh "gem push treeline-#{Treeline::VERSION}.gem"
+end

data/lib/treeline/parser.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby -wKU
+
+module Treeline
+  class Parser
+    
+    def parse(lines)
+      tree = {}
+      @path = []
+      
+      lines.each do | line |
+        # line.chomp!
+        line.rstrip!
+        line = yield(line) if block_given?
+        
+        # first, catch root elements (with no indent)
+        if (line =~ /^\S/)
+          @path = [ [ line, 0 ] ]
+        else
+          # next, catch indented elements
+          matched = /^(\s+)/.match(line)
+          unless (matched.nil?)
+            indent = matched[1].length
+            while (indent <= @path[0][1])
+              @path.shift
+            end
+            line.lstrip!
+            @path.unshift [ line, indent ]
+          end
+        end
+
+        # puts self.to_s
+        make_path_to_node(tree, @path.reverse)
+        
+      end
+      
+      tree
+    end
+  
+  protected
+  
+    def make_path_to_node(tree, path)
+      make_path_to_node(tree[path[0][0]], path[1..-1]) if (path.count > 1)
+      tree[path[0][0]] = {} if (path.count == 1)
+      tree
+    end
+    
+  private
+  
+    def to_s
+      @path.reverse.map { | item | item[0] }.join(" > ")
+    end
+    
+  end
+end

data/lib/treeline/version.rb

@@ -0,0 +1,3 @@
+module Treeline
+  VERSION = "0.1.0"
+end

data/test/01_parser_test.rb

@@ -0,0 +1,140 @@
+#!/usr/bin/env ruby -wKU
+
+require "test/unit"
+require File.expand_path('lib/treeline/parser')
+
+class ParserTest < Test::Unit::TestCase
+
+  def test_parser
+    lines = []
+    lines << "A"
+    lines << "  A::B1"
+    lines << "  A::B2"
+    lines << "    A::B2::C"
+    lines << "  A::B3"
+    lines << "    A::B3::D1"
+    lines << "    A::B3::D2"
+    
+    parser = Treeline::Parser.new
+
+    tree = parser.parse lines
+    assert_not_nil tree
+    assert_equal 1, tree.keys.count
+    assert_has_key tree, 'A'
+    
+    subtree = tree['A']
+    assert_not_nil subtree
+    assert_equal 3, subtree.keys.count
+    assert_has_key subtree, 'A::B1'
+    assert_has_key subtree, 'A::B2'
+    assert_has_key subtree, 'A::B3'
+    
+    subsubtree = subtree['A::B1']
+    assert_not_nil subsubtree
+    assert_equal 0, subsubtree.keys.count
+    
+    subsubtree = subtree['A::B2']
+    assert_not_nil subsubtree
+    assert_equal 1, subsubtree.keys.count
+    assert_has_key subsubtree, 'A::B2::C'
+    
+    subsubtree = subtree['A::B3']
+    assert_not_nil subsubtree
+    assert_equal 2, subsubtree.keys.count
+    assert_has_key subsubtree, 'A::B3::D1'
+    assert_has_key subsubtree, 'A::B3::D2'
+  end
+  
+  def test_parser_with_block
+    lines = []
+    lines << "A"
+    lines << "  A::B1"
+    lines << "  A::B2"
+    lines << "    A::B2::C"
+    lines << "  A::B3"
+    lines << "    A::B3::D1"
+    lines << "    A::B3::D2"
+    
+    parser = Treeline::Parser.new
+    
+    tree = parser.parse(lines) do | item |
+      item.downcase
+    end
+    assert_not_nil tree
+    assert_equal 1, tree.keys.count
+    assert_has_key tree, 'a'
+    
+    subtree = tree['a']
+    assert_not_nil subtree
+    assert_equal 3, subtree.keys.count
+    assert_has_key subtree, 'a::b1'
+    assert_has_key subtree, 'a::b2'
+    assert_has_key subtree, 'a::b3'
+    
+    subsubtree = subtree['a::b1']
+    assert_not_nil subsubtree
+    assert_equal 0, subsubtree.keys.count
+    
+    subsubtree = subtree['a::b2']
+    assert_not_nil subsubtree
+    assert_equal 1, subsubtree.keys.count
+    assert_has_key subsubtree, 'a::b2::c'
+    
+    subsubtree = subtree['a::b3']
+    assert_not_nil subsubtree
+    assert_equal 2, subsubtree.keys.count
+    assert_has_key subsubtree, 'a::b3::d1'
+    assert_has_key subsubtree, 'a::b3::d2'
+  end
+
+  def test_block_changing_indentation
+    lines = []
+    lines << "0 A"
+    lines << "1 A::B1"
+    lines << "1 A::B2"
+    lines << "2 A::B2::C"
+    lines << "1 A::B3"
+    lines << "2 A::B3::D1"
+    lines << "2 A::B3::D2"
+    
+    parser = Treeline::Parser.new
+    
+    tree = parser.parse(lines) do | item |
+      matched = /^(\d+)\s+(.*)$/.match(item)
+      (" " * matched[1].to_i) + matched[2]
+    end
+    assert_not_nil tree
+    assert_equal 1, tree.keys.count
+    assert_has_key tree, 'A'
+    
+    subtree = tree['A']
+    assert_not_nil subtree
+    assert_equal 3, subtree.keys.count
+    assert_has_key subtree, 'A::B1'
+    assert_has_key subtree, 'A::B2'
+    assert_has_key subtree, 'A::B3'
+    
+    subsubtree = subtree['A::B1']
+    assert_not_nil subsubtree
+    assert_equal 0, subsubtree.keys.count
+    
+    subsubtree = subtree['A::B2']
+    assert_not_nil subsubtree
+    assert_equal 1, subsubtree.keys.count
+    assert_has_key subsubtree, 'A::B2::C'
+    
+    subsubtree = subtree['A::B3']
+    assert_not_nil subsubtree
+    assert_equal 2, subsubtree.keys.count
+    assert_has_key subsubtree, 'A::B3::D1'
+    assert_has_key subsubtree, 'A::B3::D2'
+  end
+  
+protected
+
+  def assert_has_key(tree, key, msg=nil)
+    msg = "Key '#{key}' not found" if msg.nil?
+    flunk msg unless tree.has_key?(key)
+  end
+  
+end

data/treeline.gemspec

@@ -0,0 +1,24 @@
+# treeline.gemspec
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "treeline/version"
+
+Gem::Specification.new do |s|
+  s.name        = "treeline"
+  s.version     = Treeline::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Craig S. Cottingham"]
+  s.email       = ["craig.cottingham@gmail.com"]
+  s.homepage    = "https://github.com/CraigCottingham/treeline"
+  s.summary     = %q{Turns indented-line input into a tree structure.}
+  s.description = %q{Turns indented-line input into a tree structure.}
+  
+  # s.add_development_dependency "rspec"
+
+  # s.rubyforge_project = ""
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification 
+name: treeline
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Craig S. Cottingham
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-13 00:00:00 Z
+dependencies: []
+
+description: Turns indented-line input into a tree structure.
+email: 
+- craig.cottingham@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE.md
+- README.md
+- Rakefile
+- lib/treeline/parser.rb
+- lib/treeline/version.rb
+- test/01_parser_test.rb
+- treeline.gemspec
+homepage: https://github.com/CraigCottingham/treeline
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.2
+signing_key: 
+specification_version: 3
+summary: Turns indented-line input into a tree structure.
+test_files: 
+- test/01_parser_test.rb