basic_tree 1.0.0 → 1.0.1

data/Gemfile.lock

@@ -1,24 +1,28 @@
 PATH
   remote: .
   specs:
-    basic_tree (0.1.1)
+    basic_tree (1.0.0)
+      activesupport (~> 3.0.5)
+      i18n (~> 0.5.0)
 
 GEM
   remote: http://rubygems.org/
   specs:
+    activesupport (3.0.5)
     diff-lcs (1.1.2)
-    rspec (2.3.0)
-      rspec-core (~> 2.3.0)
-      rspec-expectations (~> 2.3.0)
-      rspec-mocks (~> 2.3.0)
-    rspec-core (2.3.1)
-    rspec-expectations (2.3.0)
+    i18n (0.5.0)
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.1)
+    rspec-expectations (2.5.0)
       diff-lcs (~> 1.1.2)
-    rspec-mocks (2.3.0)
+    rspec-mocks (2.5.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   basic_tree!
-  rspec (>= 2)
+  rspec (~> 2.5.0)

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Austin Schneider
+Copyright (c) 2010 Austin Schneider
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -18,16 +18,13 @@ A basic Ruby tree structure with nice syntax.
   fruit.object
   # "Fruit"
 
-  banana = fruit.children[1]
-  banana.object
-  # "Banana"
+  banana = fruit.get(2) # get the 2nd fruit
+  banana.object # "Banana"
 
-  plantain = banana.children[1]
-  plantain.object
-  # "Plantain"
+  plantain = banana.get(2) # get the 2nd banana
+  plantain.object # "Plantain"
 
-  plantain.parent.object
-  # "Banana""
+  plantain.parent.object # "Banana"
 
   plantain.path.map(&:object)
   # ["Fruit", "Banana", "Plantain"]
@@ -44,23 +41,17 @@ A basic Ruby tree structure with nice syntax.
   banana.siblings.map(&:object)
   # ["Apple", "Orange"]
 
-  plantain.root.object
-  # "Fruit"
+  plantain.root.object # "Fruit"
 
-  plantain.level
-  # 3
+  plantain.level # 3
 
-  banana.root?
-  # false
+  banana.root? # false
 
-  fruit.root?
-  # true
+  fruit.root? # true
 
-  banana.leaf?
-  # false
+  banana.leaf? # false
 
-  plantain.leaf?
-  # true
+  plantain.leaf? # true
 
 == Note on Patches/Pull Requests
 
@@ -74,4 +65,4 @@ A basic Ruby tree structure with nice syntax.
 
 == Copyright
 
-Copyright (c) 2010 Austin Schneider. See LICENSE for details.
+See LICENSE for details.

data/Rakefile

@@ -1,3 +1,8 @@
 require 'bundler'
 
-Bundler::GemHelper.install_tasks
+Bundler::GemHelper.install_tasks
+
+desc "Run tests"
+task :test do
+  system 'rspec spec'
+end

data/basic_tree.gemspec

@@ -1,6 +1,6 @@
 # -*- encoding: utf-8 -*-
 $:.push File.expand_path("../lib", __FILE__)
-require "basic_tree"
+require "basic_tree/version"
 
 Gem::Specification.new do |s|
   s.name = "basic_tree"
@@ -19,5 +19,8 @@ Gem::Specification.new do |s|
   s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_development_dependency 'rspec', ">= 2"
+  s.add_development_dependency 'rspec', "~> 2.5.0"
+
+  s.add_dependency 'i18n', "~> 0.5.0"
+  s.add_dependency 'activesupport', "~> 3.0.5"
 end

data/lib/basic_tree/version.rb

@@ -0,0 +1,5 @@
+class BasicTree
+
+  VERSION = "1.0.1"
+
+end

data/lib/basic_tree.rb

@@ -1,22 +1,64 @@
+require 'active_support/core_ext/object'
+
 class BasicTree
 
   include Enumerable
 
-  VERSION = "1.0.0"
+  class Kids < Array
+    def swap!(p1, p2)
+      self[p1], self[p2] = self[p2], self[p1]
+    end
+  end
 
+  ##################################################
+
+  # TODO: test
   def initialize(object, parent = nil, &block)
     self.object = object
-    if parent
-      self.parent = parent
-      parent.children << self
-    end
+    parent.try(:insert!, self)
     instance_eval(&block) if block_given?
   end
 
-  attr_accessor :object, :parent
-
+  # TODO: test
   def add(object, &block)
-    self.class.new(object, self, &block)
+    if object.is_a?(self.class)
+      insert!(object)
+    else
+      self.class.new(object, self, &block)
+    end
+  end
+
+  # TODO: test
+  def insert!(basic_tree)
+    raise ArgumentError, "Must be a #{self.class}" unless basic_tree.is_a?(self.class)
+    basic_tree.send(:parent=, self)
+    kids << basic_tree
+  end
+
+  # TODO: self
+  def remove!(basic_tree)
+    raise ArgumentError, "Must be a #{self.class}" unless basic_tree.is_a?(self.class)
+    raise StandardError, "Can't remove root" if root?
+    parent.send(:kids).delete(self)
+    basic_tree.send(:parent=, nil)
+  end
+
+  # TODO: test
+  def move_up!
+    raise "Already first" if first?
+    parent.send(:kids).swap!(position, position - 1)
+  end
+
+  # TODO: test
+  def move_down!
+    raise "Already last" if last?
+    parent.send(:kids).swap!(position, position + 1)
+  end
+
+  ##################################################
+
+  def children
+    kids.dup
   end
 
   def path
@@ -28,17 +70,28 @@ class BasicTree
   end
 
   def descendants
-    children.map { |c| [c] + c.descendants }.flatten
+    d = []
+    kids.each { |k| d += k.descendants.unshift(k) }
+    d
   end
 
   def subtree
-    [self] + descendants
+    descendants.unshift(self)
+  end
+
+  def siblings_and_self
+    root? ? [self] : parent.children
   end
 
   def siblings
-    root? ? [] : parent.children.select { |child| child != self }
+    root? ? [] : siblings_and_self.delete_if { |s| s == self }
   end
 
+  ##################################################
+
+  attr_reader :parent
+  attr_accessor :object
+
   def root
     path.first
   end
@@ -47,16 +100,37 @@ class BasicTree
     path.size
   end
 
+  def position
+    siblings_and_self.index(self)
+  end
+
+  ##################################################
+
   def root?
     !parent
   end
 
   def leaf?
-    children.empty?
+    kids.empty?
   end
 
-  def children
-    @children ||= []
+  def first?
+    root? || siblings_and_self[0] == self
+  end
+
+  def last?
+    root? || siblings_and_self.last == self
+  end
+
+  ##################################################
+  private
+
+  attr_writer :parent
+
+  def kids
+    @kids ||= Kids.new
   end
 
-end
+end
+
+require 'basic_tree/version'

data/spec/lib/basic_tree_spec.rb

@@ -16,74 +16,137 @@ describe BasicTree do
     @a12 = @a1.children[1]
   end
 
-  it "path" do
-    @a.path.should == [@a]
-    @a1.path.should == [@a, @a1]
-    @a11.path.should == [@a, @a1, @a11]
-    @a12.path.should == [@a, @a1, @a12]
-    @a2.path.should == [@a, @a2]
-  end
+  describe "instance methods" do
+    before do
+      @object = "soccer"
+      @bt = BasicTree.new(@object)
+    end
 
-  it "ancestors" do
-    @a.ancestors.should == []
-    @a1.ancestors.should == [@a]
-    @a11.ancestors.should == [@a, @a1]
-    @a12.ancestors.should == [@a, @a1]
-    @a2.ancestors.should == [@a]
-  end
+    describe "#leaf?" do
+      context("with no children") { it { @bt.should be_leaf } }
 
-  it "descendants" do
-    @a.descendants.should == [@a1, @a11, @a12, @a2]
-    @a1.descendants.should == [@a11, @a12]
-    @a11.descendants.should == []
-    @a12.descendants.should == []
-    @a2.descendants.should == []
-  end
+      context("with children") do
+        before { @bt.add("ball") }
 
-  it "subtree" do
-    @a.subtree.should == [@a, @a1, @a11, @a12, @a2]
-    @a1.subtree.should == [@a1, @a11, @a12]
-    @a11.subtree.should == [@a11]
-    @a12.subtree.should == [@a12]
-    @a2.subtree.should == [@a2]
-  end
+        it { @bt.should_not be_leaf }
+      end
+    end
 
-  it "siblings" do
-    @a.siblings.should == []
-    @a1.siblings.should == [@a2]
-    @a11.siblings.should == [@a12]
-    @a12.siblings.should == [@a11]
-    @a2.siblings.should == [@a1]
-  end
+    describe "#root?" do
+      context("with no parent") { it { @bt.should be_root } }
+
+      context("as a child") do
+        before { BasicTree.new("sport").add(@bt) }
 
-  it "root" do
-    [@a, @a1, @a11, @a12, @a2].each do |m|
-      m.root.should == @a
+        it { @bt.should_not be_root }
+      end
     end
-  end
 
-  it "level" do
-    @a.level.should == 1
-    @a1.level.should == 2
-    @a11.level.should == 3
-    @a12.level.should == 3
-    @a2.level.should == 2
-  end
+    describe "#level" do
+      it "returns the size of the path" do
+        @bt.stub!(:path => 13.times.map(&:to_i))
+        @bt.level.should eq(13)
+      end
+    end
 
-  it "root?" do
-    @a.root?.should be_true
-    @a1.root?.should be_false
-    @a11.root?.should be_false
-    @a12.root?.should be_false
-    @a2.root?.should be_false
-  end
+    describe "#root" do
+      it "returns the first item in the path" do
+        @bt.stub!(:path => [3, 2])
+        @bt.root.should eq(3)
+      end
+    end
+
+    describe "#path" do
+      it "returns the ancestors and itself" do
+        @bt.stub!(:ancestors => [3, 4])
+        @bt.path.should eq([3, 4, @bt])
+      end
+    end
+
+    describe "#ancestors" do
+      context("when root") do
+        it("returns empty array") { @bt.ancestors.should eq([]) }
+      end
+
+      context "when not root" do
+        before { BasicTree.new("Fun Stuff").add("Sports").add(@bt) }
+
+        it "returns parent's path" do
+          @bt.ancestors.should eq(@bt.parent.path)
+        end
+      end
+    end
+
+    describe "#children" do
+      context "with none" do
+        it "returns empty array" do
+          @bt.children.should eq([])
+        end
+      end
+
+      context "with some" do
+        before do
+          @c1 = @bt.add("c1")
+          @c2 = @bt.add("c2")
+        end
+
+        it "returns them" do
+          @bt.children.should eq([@c1, @c2])
+        end
+      end
+    end
+
+    describe "#descendants" do
+      context "with no children" do
+        it { @bt.descendants.should eq([]) }
+      end
+
+      context "when children exist, and some of them have children" do
+        before do
+          @ball = @bt.add("ball")
+          @size = @ball.add("size")
+          @four = @size.add("4")
+          @goal = @bt.add("goal")
+        end
+
+        it "returns array" do
+          @bt.descendants.should eq([@ball, @size, @four, @goal])
+        end
+      end
+    end
 
-  it "leaf?" do
-    @a.leaf?.should be_false
-    @a1.leaf?.should be_false
-    @a11.leaf?.should be_true
-    @a12.leaf?.should be_true
-    @a2.leaf?.should be_true
+    describe "#subtree" do
+      before do
+        @result = [1, 2, 3]
+        @bt.stub!(:descendants => @result)
+      end
+
+      it "should add itself to the front of descendants" do
+        @bt.descendants.should_receive(:unshift).with(@bt)
+        @bt.subtree
+      end
+
+      it { @bt.subtree.should eq(@result) }
+    end
+
+    describe "#siblings" do
+      context "when root" do
+        it { @bt.siblings.should eq([]) }
+      end
+
+      context "when not root" do
+        before do
+          @k1 = mock(BasicTree)
+          @k2 = mock(BasicTree)
+
+          @bt.stub!(:parent => mock(BasicTree, :children => [@k1, @bt, @k2]))
+        end
+
+        it "returns parent's children (without itself)" do
+          @bt.siblings.should eq([@k1, @k2])
+        end
+      end
+    end
   end
 
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 1
   - 0
-  - 0
-  version: 1.0.0
+  - 1
+  version: 1.0.1
 platform: ruby
 authors: 
 - Austin Schneider
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-21 00:00:00 -05:00
+date: 2011-03-09 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -23,13 +23,45 @@ dependencies:
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
         segments: 
         - 2
-        version: "2"
+        - 5
+        - 0
+        version: 2.5.0
   type: :development
   version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: i18n
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 5
+        - 0
+        version: 0.5.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 0
+        - 5
+        version: 3.0.5
+  type: :runtime
+  version_requirements: *id003
 description: A basic tree structure.
 email: 
 - soccer022483@gmail.com
@@ -40,6 +72,7 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- .gemtest
 - .gitignore
 - .rspec
 - .rvmrc
@@ -50,6 +83,7 @@ files:
 - Rakefile
 - basic_tree.gemspec
 - lib/basic_tree.rb
+- lib/basic_tree/version.rb
 - spec/lib/basic_tree_spec.rb
 - spec/spec_helper.rb
 has_rdoc: true
@@ -84,5 +118,6 @@ rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: A basic tree structure.
-test_files: []
-
+test_files: 
+- spec/lib/basic_tree_spec.rb
+- spec/spec_helper.rb