weskit 0.0.2 → 0.1.0

data/lib/weskit/wml.rb

@@ -1,11 +1,17 @@
+require 'weskit/version'
+
 module Weskit
   module WML
+    def self.require_all files, folder = nil
+      folder = (folder.to_s || '') + '/'
+      files.collect {|file| require "weskit/wml/#{folder}#{file}"}
+    end
   end
 end
 
-directory = File.dirname __FILE__
-files     = File.join directory, 'wml', '*.rb'
-
-Dir[files].each do |file|
-  require file
-end
+w = Weskit::WML
+w.require_all %w{validator grammar searchable container}, :mixins
+w.require_all %w{object}, :extensions
+w.require_all %w{error invalid_identifier invalid_item invalid_option invalid_parameters parse_error read_error}, :errors
+w.require_all %w{item_formatter attribute element ansi_color ansi_color_attribute ansi_color_element}, :formatters
+w.require_all %w{item items attribute attributes builder element elements formatter wml parser root}

data/lib/weskit.rb

@@ -1,3 +1,3 @@
-require 'weskit/lobby'
+require 'weskit/mp'
 require 'weskit/version'
-require 'weskit/wml'
+require 'weskit/wml'

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'weskit'

data/spec/wml/attribute_spec.rb

@@ -0,0 +1,51 @@
+require 'wml_spec_helper'
+
+describe Weskit::WML::Attribute do
+  include WMLHelpers
+
+  let(:attribute) { Weskit::WML::Attribute.new :foo, :bar }
+
+  it 'should change code to false when setting translatable to true' do
+    attribute.should_not be_code
+    attribute.should_not be_translatable
+
+    attribute.code = true
+    
+    attribute.should be_code
+    attribute.should_not be_translatable
+    
+    attribute.translatable = true
+
+    attribute.should_not be_code
+    attribute.should be_translatable
+  end
+
+  it 'should change translatable to false when setting code to true' do
+    attribute.should_not be_code
+    attribute.should_not be_translatable
+
+    attribute.translatable = true
+    
+    attribute.should_not be_code
+    attribute.should be_translatable
+    
+    attribute.code = true
+
+    attribute.should be_code
+    attribute.should_not be_translatable
+  end
+
+  it 'should respond to predicates' do
+    attr1 = attribute.dup.merge :code => true
+    attr2 = attribute.dup.merge :translatable => true
+    attr3 = Weskit::WML::Attribute.new :bar, "baz \n bat"
+
+    attr1.should be_code
+    attr2.should be_translatable
+    attr3.should be_multiline
+
+    attr1.should be_text
+    attr2.should be_text
+    attr3.should be_text
+  end
+end

data/spec/wml/attributes_spec.rb

@@ -0,0 +1,19 @@
+require 'wml_spec_helper'
+
+describe Weskit::WML::Attributes do
+  include WMLHelpers
+
+  let(:attribute)  { Weskit::WML::Attribute.new :foo, :bar }
+  let(:attributes) { Weskit::WML::Attributes.new }
+
+  it 'has hash like access' do
+    attributes << attribute
+    attributes[:foo].should match_value_of(:bar)
+    attributes[:foo].attribute.should have_same_representation_as(attribute)
+  end
+
+  it 'store attributes only' do
+    expect { attributes.push attribute }.to change { attributes.size }.from(0).to(1)
+    expect { attributes.push :boo }.to raise_error(Weskit::WML::Errors::InvalidItem)
+  end
+end

data/spec/wml/builder_spec.rb

@@ -0,0 +1,52 @@
+require 'wml_spec_helper'
+
+describe Weskit::WML::Builder do
+  include WMLHelpers
+
+  let(:element) { Weskit::WML::Element.new :foo }
+
+  specify 'builds attributes' do
+    reference = Weskit::WML::Element.new(:foo)                 \
+      << Weskit::WML::Attribute.new(:bar, :foo)                \
+      << Weskit::WML::Attribute.new(:baz, :foo, :code => true) \
+      << Weskit::WML::Attribute.new(:bat, :foo, :translatable => true)
+
+    element.build do
+      bar :foo
+      baz :foo, :code => true
+      bat :foo, :translatable => true
+    end
+
+    element.should have_same_representation_as(reference)
+  end
+
+  specify 'builds elements' do
+    reference = Weskit::WML::Element.new(:foo) \
+      << Weskit::WML::Element.new(:baz)        \
+      << Weskit::WML::Element.new(:bar)        \
+      << sample_amendment
+
+    element.build do
+      baz {}
+      bar {}
+      bar :amendment => true do
+        bat :baz
+      end
+    end
+
+    element.should have_same_representation_as(reference)
+  end
+
+  specify 'convert hashes' do
+    hash = {
+      :a => :foo,
+      :b => {
+        :c => :bar
+      }
+    }
+
+    converted = Weskit::WML::Builder.convert hash
+    converted[:a].should match_value_of(:foo)
+    converted.elements[:c].should match_value_of(:bar)
+  end
+end

data/spec/wml/element_spec.rb

@@ -0,0 +1,20 @@
+require 'wml_spec_helper'
+
+describe Weskit::WML::Element do
+  include WMLHelpers
+
+  let(:element) { Weskit::WML::Element.new :foo }
+
+  it_should_behave_like 'a container' do
+    let(:container) { element }
+  end
+
+  it_should_behave_like 'a searchable' do
+    let(:searchable) { element }
+  end
+
+  it 'can be amending element' do
+    element = Weskit::WML::Element.new :foo, :amendment => true
+    element.should be_amendment
+  end
+end

data/spec/wml/elements_spec.rb

@@ -0,0 +1,25 @@
+require 'wml_spec_helper'
+
+describe Weskit::WML::Elements do
+  include WMLHelpers
+
+  let(:element)  { Weskit::WML::Element.new :foo }
+  let(:elements) { Weskit::WML::Elements.new }
+
+  it_should_behave_like 'a searchable' do
+    let(:searchable) { elements }
+  end
+
+  it 'has hash like access' do
+    element = Weskit::WML::Element.new(:foo).push Weskit::WML::Attribute.new(:bat, :baz)
+    elements.push element
+
+    elements[0].should be(element)
+    elements[:bat].should match_value_of(:baz)
+  end
+
+  it 'store elements only' do
+    expect { elements.push element }.to change { elements.size }.from(0).to(1)
+    expect { elements.push :boo }.to raise_error(Weskit::WML::Errors::InvalidItem)
+  end
+end

data/spec/wml/formatter_spec.rb

@@ -0,0 +1,42 @@
+require 'wml_spec_helper'
+
+describe Weskit::WML::Formatter do
+  include WMLHelpers
+
+  subject { Weskit::WML::Formatter.default }
+
+  let(:formatter) { subject }
+
+  specify 'can be initialized as color default or pain' do
+    Weskit::WML::Formatter.color.should be_kind_of(Weskit::WML::Formatter)
+    Weskit::WML::Formatter.default.should be_kind_of(Weskit::WML::Formatter)
+    Weskit::WML::Formatter.plain.should be_kind_of(Weskit::WML::Formatter)
+  end
+
+  specify 'default formatter can be replaced' do
+    default = Weskit::WML::Formatter.default
+    expect { Weskit::WML::Formatter.default = Weskit::WML::Formatter.color }.to change {
+      Weskit::WML::Formatter.default
+    }.from(Weskit::WML::Formatter.plain).to(Weskit::WML::Formatter.color)
+    Weskit::WML::Formatter.default = default
+  end
+
+  context 'plain' do
+    it 'formatts attributes' do
+      formatted = formatter.format Weskit::WML::Attribute.new(:foo, 'bar')
+      formatted.should eq('foo=bar')
+
+      formatted = formatter.format Weskit::WML::Attribute.new(:foo, 'bar', :code => true)
+      formatted.should eq('foo=<<bar>>')
+
+      formatted = formatter.format Weskit::WML::Attribute.new(:foo, 'bar', :translatable => true)
+      formatted.should eq('foo=_"bar"')
+    end
+
+    it 'formatts elements' do
+      element = Weskit::WML::Element.new :foo
+      formatted = formatter.format element
+      formatter.format(element).should have_same_representation_as(element)
+    end
+  end
+end

data/spec/wml/item_spec.rb

@@ -0,0 +1,25 @@
+require 'wml_spec_helper'
+
+describe Weskit::WML::Item do
+  include WMLHelpers
+
+  let(:item) { Weskit::WML::Item.new :foo }
+
+  it 'should compare items by name or class' do
+    bat = Weskit::WML::Item.new :bat
+
+    (item <=> bat).should eq(1)
+    (bat <=> item).should eq(-1)
+
+    bat = Weskit::WML::Element.new :bat
+
+    (item <=> bat).should eq(1)
+    (bat <=> item).should eq(-1)
+
+    (item <=> :bat).should be_nil
+  end
+
+  it 'should have name that is identifier' do
+    item.should have_identifier_of(:foo)
+  end
+end

data/spec/wml/items_spec.rb

@@ -0,0 +1,15 @@
+require 'wml_spec_helper'
+
+describe Weskit::WML::Items do
+  include WMLHelpers
+
+  let(:items) { Weskit::WML::Items.new }
+
+  it_should_behave_like 'a container' do
+    let(:container) { items }
+  end
+
+  it 'has contents formatter' do
+    expect { items.formatter = Weskit::WML::Formatter.color }.to change { items.formatter }.from(Weskit::WML::Formatter.default).to(Weskit::WML::Formatter.color)
+  end
+end

data/spec/wml/parser_spec.rb

@@ -0,0 +1,60 @@
+require 'wml_spec_helper'
+require 'awesome_print'
+
+describe Weskit::WML::Parser do
+  include WMLHelpers
+
+  describe 'parse' do
+    specify 'empty lines' do
+      Weskit::WML::Parser.string document_with_empty_lines
+    end
+
+    context 'attribute' do
+      specify 'raw' do
+        parsed = Weskit::WML::Parser.string 'a=b'
+        parsed[:a].should match_value_of(:b)
+      end
+
+      specify 'code' do
+        parsed = Weskit::WML::Parser.string ' a= <<b>> '
+        parsed[:a].attribute.should be_code
+        parsed[:a].should match_value_of(:b)
+      end
+
+      specify 'multiline' do
+        parsed = Weskit::WML::Parser.string %Q{a= "b \n c"}
+        parsed[:a].attribute.should be_multiline
+        parsed[:a].should match_value_of("b \n c")
+      end
+
+      specify 'escape sequence' do
+        parsed = Weskit::WML::Parser.string %Q{ a= "b "" c" }
+        parsed[:a].should match_value_of('b " c')
+      end
+
+      specify 'translatable' do
+        parsed = Weskit::WML::Parser.string ' a= _ "b" '
+        parsed[:a].attribute.should be_translatable
+        parsed[:a].should match_value_of(:b)
+      end
+    end
+
+    context 'element' do
+      specify 'tags' do
+        expect {
+          Weskit::WML::Parser.string "[foo]\n[/bar]"
+        }.to raise_error Weskit::WML::Errors::ParseError
+      end
+
+      specify 'default' do
+        parsed = Weskit::WML::Parser.string "[foo]\n[/foo]"
+        parsed[0].should have_identifier_of(:foo)
+      end
+
+      specify 'amending' do
+        parsed = Weskit::WML::Parser.string document_with_amendment
+        parsed[0][:bat].should match_value_of(:baz)
+      end
+    end
+  end
+end

data/spec/wml/root_spec.rb

@@ -0,0 +1,15 @@
+require 'wml_spec_helper'
+
+describe Weskit::WML::Root do
+  include WMLHelpers
+
+  let(:root) { Weskit::WML::Root.new }
+
+  it_should_behave_like 'a container' do
+    let(:container) { root }
+  end
+
+  it_should_behave_like 'a searchable' do
+    let(:searchable) { root }
+  end
+end

data/spec/wml_helpers.rb

@@ -0,0 +1,40 @@
+module WMLHelpers
+  def sample_amendment
+    e = Weskit::WML::Element.new :bar, :amendment => true
+    e.push Weskit::WML::Attribute.new :bat, :baz
+  end
+
+  def document_with_amendment
+    <<-doc
+      [foo]
+      [/foo]
+      [+foo]
+        bat=baz
+      [/foo]
+    doc
+  end
+
+  def document_with_empty_lines
+    <<-doc
+      
+      [a]
+        b=c
+      [/a]
+      
+      [d]
+        
+        e=f
+        
+      [/d]
+      
+    doc
+  end
+
+  def sample_elements
+    a = Weskit::WML::Element.new :a
+    b = Weskit::WML::Element.new :b
+    c = Weskit::WML::Element.new :c
+    d = Weskit::WML::Element.new :d
+    a << (b.push c, d)
+  end
+end

data/spec/wml_matchers.rb

@@ -0,0 +1,17 @@
+RSpec::Matchers.define :have_identifier_of do |name|
+  match do |actual|
+    actual.name == Weskit::WML::Item.identifier(name)
+  end
+end
+
+RSpec::Matchers.define :have_same_representation_as do |other|
+  match do |actual|
+    actual.to_s == other.to_s
+  end
+end
+
+RSpec::Matchers.define :match_value_of do |value|
+  match do |actual|
+    actual.to_s == value.to_s
+  end
+end

data/spec/wml_shared_examples.rb

@@ -0,0 +1,68 @@
+shared_examples_for 'a container' do
+  it 'can delete stored item' do
+    container << (element = Weskit::WML::Element.new :foo)
+    expect { container.delete element }.to change { container.contents.size }.by(-1)
+  end
+
+  it 'can determine if item exists' do
+    container << (element = Weskit::WML::Element.new :foo)
+    container.exists?(element).should be_true
+  end
+
+  it 'expose attrs and elems' do
+    container << Weskit::WML::Attribute.new(:foo, :bar)
+    container << Weskit::WML::Element.new(:baz)
+
+    container.should have(2).contents
+    container.should have(1).attrs
+    container.should have(1).elems
+  end
+
+  it 'expose contents methods' do
+    %w{each empty? first last size to_a}.each do |method|
+      container.should respond_to(method)
+    end
+  end
+
+  it 'has associated builder' do
+    container.build do
+      key :foo
+      name {}
+    end
+
+    container[:key].should match_value_of(:foo)
+    container[0].should have_same_identifier_as(:name)
+  end
+  
+  it 'has hash like access' do
+    container << (attribute = Weskit::WML::Attribute.new :foo, :bar)
+    container << (element = Weskit::WML::Element.new :baz)
+
+    container[:foo].should match_value_of(:bar)
+    container[0].should have_same_representation_as(element)
+  end
+end
+
+shared_examples_for 'a searchable' do
+  specify 'append amending elements' do
+    searchable << Weskit::WML::Element.new(:bar)
+    searchable << sample_amendment
+
+    searchable.should have(1).elems
+    searchable.find(:bar, false)[:bat].should match_value_of(:baz)
+  end
+
+  specify 'finds nested elements' do
+    searchable << sample_elements
+    searchable.find(:a, false).find(:b).find(:c).size.should eq(1)
+  end
+
+  specify 'finds elements recursively' do
+    searchable << sample_elements
+    searchable << Weskit::WML::Element.new(:b)
+
+    searchable.find_recursively do |item|
+      item.name == :b
+    end.size.should eq(2)
+  end
+end

data/spec/wml_spec_helper.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+require 'wml_helpers'
+require 'wml_matchers'
+require 'wml_shared_examples'

data/weskit.gemspec

@@ -9,16 +9,19 @@ Gem::Specification.new do |s|
   s.email       = ['filip.pyda@gmail.com']
   s.homepage    = 'https://github.com/f6p/weskit'
   s.summary     = 'Ruby utilies for BfW'
-  s.description = 'Pls do me a favor and do not look at sources if you dont have to. Thx!'
+  s.description = 'Tools for interacting with Wesnoth Markup Language, MP Server and such.'
 
   # s.rubyforge_project = 'weskit'
 
   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.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename f }
   s.require_paths = ['lib']
 
-  # specify any dependencies here; for example:
-  # s.add_development_dependency 'rspec'
-  # s.add_runtime_dependency 'rest-client'
+  s.add_development_dependency 'awesome_print'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+  s.add_runtime_dependency 'polyglot'
+  s.add_runtime_dependency 'term-ansicolor'
+  s.add_runtime_dependency 'treetop'
 end