weskit 0.0.2 → 0.1.0

data/lib/weskit/wml/grammars/wml.treetop

@@ -0,0 +1,195 @@
+require 'treetop'
+require 'weskit/wml'
+
+grammar WesnothMarkupLanguage
+  rule document
+    contents {
+      def wml
+        ::Weskit::WML::Root.new.push *::Weskit::WML::Mixins::Grammar.reject_non_wml(elements)
+      end
+    }
+  end
+
+  # parts -------------------------------------------------------------------------------
+
+  rule identifier
+    [a-z] [a-z_]* {
+      def name
+        text_value
+      end
+    }
+  end
+
+  rule raw_string
+    (!eol .)* {
+      def data
+        text_value
+      end
+    }
+  end
+
+  rule code_content
+    (!'>>' content)* {
+      def contents
+        text_value
+      end
+    }
+  end
+
+  rule code_string
+    '<<' string:code_content '>>' {
+      def data
+        string.contents
+      end
+    }
+  end
+
+  rule multiline_content
+    (!quote content)* {
+      def contents
+        text_value
+      end
+    }
+  end
+
+  rule multiline_string
+    (quote string:multiline_content quote)* {
+      def data
+        elements.collect(&:string).collect(&:contents).join '"'
+      end
+    }
+  end
+
+  rule translatable_string
+    '_' lws string:multiline_string {
+      def data
+        string.contents
+      end
+    }
+  end
+
+  rule opening_tag
+    lws '[' tag:identifier ']' fws {
+      def name
+        tag.name
+      end
+    }
+  end
+
+  rule amending_tag
+    lws '[+' tag:identifier ']' fws {
+      def name
+        tag.name
+      end
+    }
+  end
+
+  rule closing_tag
+    lws '[/' tag:identifier ']' fws {
+      def name
+        tag.name
+      end
+    }
+  end
+
+  rule blank_line
+    ws* "\n"
+  end
+
+  rule item
+    code_attribute / multiline_attribute / translatable_attribute / attribute / amending_element / element
+  end
+
+  rule contents
+    (blank_line / item)* {
+      def items
+        ::Weskit::WML::Mixins::Grammar.reject_non_wml elements
+      end
+    }
+  end
+
+  # items -------------------------------------------------------------------------------
+
+  rule attribute
+    lws id:identifier lws equals value:raw_string eol {
+      def item
+        ::Weskit::WML::Attribute.new id.name, value.data
+      end
+    }
+  end
+
+  rule code_attribute
+    lws id:identifier lws equals lws value:code_string fws {
+      def item
+        ::Weskit::WML::Attribute.new id.name, value.data, :code => true
+      end
+    }
+  end
+
+  rule multiline_attribute
+    lws id:identifier lws equals lws value:multiline_string fws {
+      def item
+        ::Weskit::WML::Attribute.new id.name, value.data
+      end
+    }
+  end
+
+  rule translatable_attribute
+    lws id:identifier lws equals lws '_' lws value:multiline_string fws {
+      def item
+        ::Weskit::WML::Attribute.new id.name, value.data, :translatable => true
+      end
+    }
+  end
+
+  rule element
+    open:opening_tag nested:contents close:closing_tag {
+      def item
+        ::Weskit::WML::Mixins::Grammar.raise_on_mismatching open, close
+        ::Weskit::WML::Element.new(open.name).push *nested.items
+      end
+    }
+  end
+
+  rule amending_element
+    open:amending_tag nested:contents close:closing_tag {
+      def item
+        ::Weskit::WML::Mixins::Grammar.raise_on_mismatching open, close
+        ::Weskit::WML::Element.new(open.name, :amendment => true).push *nested.items
+      end
+    }
+  end
+
+  # helpers -----------------------------------------------------------------------------
+
+  rule content
+    "\n" / .
+  end
+
+  rule eol
+    "\n" / !.
+  end
+
+  rule equals
+    '='
+  end
+
+  rule quote
+    '"'
+  end
+
+  # whitespace
+  rule ws
+    "\s" / "\t"
+  end
+
+  # leading whitespaces
+  rule lws
+    ws*
+  end
+
+  # following whitespaces
+  rule fws
+    ws* eol
+  end
+end

data/lib/weskit/wml/item.rb

@@ -0,0 +1,89 @@
+module Weskit::WML
+  class Item
+    include Comparable, Mixins::Validator
+
+    attr_reader :name
+
+    def <=> other
+      case other
+        when self.class then "#{name}" <=> "#{other.name}"
+        when Item then "#{self.class}" <=> "#{other.class}"
+        else nil
+      end
+    end
+
+    def formatter= item
+      raise_unless Formatter, item
+      @formatter = item
+    end
+
+    def initialize name, defaults = {}
+      self.name = name
+      merge defaults
+    end
+
+    def merge options = {}
+      raise_unless Hash, options
+
+      options.each do |option, value|
+        raise_if_missing self, option
+        send "#{option}=", value
+      end
+
+      self
+    end
+
+    def name= name
+      raise_if_invalid name
+      @name = Item.identifier name
+    end
+
+    def to_s
+      formatter.format_detached self
+    end
+
+    alias_method :to_str, :to_s
+
+    class << self
+      def identifier name
+        "#{name}".to_sym
+      end
+
+      private
+
+      def attachable_to name
+        class_eval <<-code
+          attr_reader :#{name}
+
+          def #{name}= item
+            raise_unless Element, item
+            @#{name} = item
+          end
+
+          def #{name}?
+            !!#{name}
+          end
+
+          alias_method :attach_to, :#{name}=
+
+          def detach
+            if #{name}?
+              @#{name}.delete self
+              @#{name} = nil
+            end
+            self
+          end
+
+          def distance
+            #{name} ? #{name}.distance + 1 : 0
+          end
+
+          def formatter
+            current_formatter = @formatter || Formatter.default
+            #{name} ? #{name}.formatter : current_formatter
+          end
+        code
+      end
+    end
+  end
+end

data/lib/weskit/wml/items.rb

@@ -0,0 +1,29 @@
+module Weskit::WML
+  class Items
+    include Enumerable, Mixins::Container, Mixins::Validator
+
+    attr_reader :contents
+
+    def formatter
+      @formatter or Formatter.default
+    end
+
+    def formatter= item
+      raise_unless Formatter, item
+      @formatter = item
+    end
+
+    def initialize *items
+      @contents = []
+      push *items
+    end
+
+    def to_s
+      @contents.collect do |item|
+        formatter.format_detached item, formatter
+      end.join formatter.separator
+    end
+
+    alias_method :to_str, :to_s
+  end
+end

data/lib/weskit/wml/mixins/container.rb

@@ -0,0 +1,96 @@
+require 'forwardable'
+
+module Weskit::WML::Mixins
+  module Container
+    extend Forwardable
+    include ::Weskit::WML::Mixins::Validator
+
+    def_delegators :contents, :each, :empty?, :first, :last, :size, :to_a
+
+    def [] key
+      case key
+        when Integer then elements[key]
+        else attributes[key] rescue nil
+      end
+    end
+
+    def << item
+      raise_unless ::Weskit::WML::Item, item
+      add item
+      self
+    end
+
+    def attributes
+      ::Weskit::WML::Attributes.new *(select_type_of ::Weskit::WML::Attribute)
+    end
+
+    alias_method :attrs, :attributes
+
+    def build &contents
+      push *(::Weskit::WML::Builder.build &contents)
+    end
+
+    def delete item
+      contents.delete_if {|i| i.equal? item}
+    end
+
+    def elements
+      ::Weskit::WML::Elements.new *(select_type_of ::Weskit::WML::Element)
+    end
+
+    alias_method :elems, :elements
+
+    def exists? item
+      contents.any? {|i| i.equal? item}
+    end
+
+    def push *items
+      items.each {|i| self << i}
+      self
+    end
+
+    private
+
+    def add item
+      return nil if exists? item
+
+      case item
+        when ::Weskit::WML::Attribute then append_attribute item
+        else contents << item
+      end
+
+      item
+    end
+
+    def append item
+      raise_unless ::Weskit::WML::Element, item
+      find(item.name, false).last.push(*item.contents) rescue nil
+    end
+
+    def append_attribute item
+      raise_unless ::Weskit::WML::Attribute, item
+      index = attribute_index item
+      index ? contents[index] = item : contents << item
+    end
+
+    def attribute name
+      name = ::Weskit::WML::Item.identifier name
+      contents.detect do |item|
+        item.is_a? ::Weskit::WML::Attribute and item.name == name
+      end
+    end
+
+    def attribute_index item
+      contents.find_index {|i| i == item}
+    end
+
+    def attribute_value name
+      found = attribute name
+      found ? found.value : nil
+    end
+
+    def select_type_of constant
+      contents.select {|i| i.is_a? constant}
+    end
+  end
+end

data/lib/weskit/wml/mixins/grammar.rb

@@ -0,0 +1,17 @@
+module Weskit::WML::Mixins
+  module Grammar
+    module_function
+
+    def raise_on_mismatching opening, closing
+      unless opening.name == closing.name
+        raise ::Weskit::WML::Errors::ParseError, 'Invalid element'
+      end
+    end
+
+    def reject_non_wml elements
+      elements.reduce(Array.new) do |array, element|
+        array << element.item if element.respond_to? :item ; array
+      end
+    end
+  end
+end

data/lib/weskit/wml/mixins/searchable.rb

@@ -0,0 +1,43 @@
+module Weskit::WML::Mixins
+  module Searchable
+    def find_recursively &criteria
+      ::Weskit::WML::Elements.new *elements_recursively.select(&criteria)
+    end
+
+    def elements_recursively
+      element_contents + element_contents.reduce(Array.new) do |r, i|
+        r + i.elements_recursively
+      end
+    end
+
+    private
+
+    def append item
+      find_elements(item.name, false).last.push(*item.contents) rescue nil
+    end
+
+    def append? item
+      item.is_a? ::Weskit::WML::Element and item.amendment?
+    end
+
+    def base nested
+      nested ? nested_contents : contents
+    end
+
+    def element_contents
+      contents.select {|i| i.is_a? ::Weskit::WML::Element}
+    end
+
+    def find_elements name, nested = false
+      name  = ::Weskit::WML::Item.identifier name
+      found = base(nested).select {|i| i.is_a? ::Weskit::WML::Element and i.name == name}
+      ::Weskit::WML::Elements.new *found
+    end
+
+    def nested_contents
+      contents.reduce(Array.new) do |r, i|
+        r + i.contents
+      end
+    end
+  end
+end

data/lib/weskit/wml/mixins/validator.rb

@@ -0,0 +1,29 @@
+module Weskit::WML::Mixins
+  module Validator
+    module_function
+
+    def raise_unless type, item
+      unless item.is_a? type
+        raise ::Weskit::WML::Errors::InvalidItem, "Invalid #{type}"
+      end
+    end
+
+    def raise_if_invalid identifier
+      unless "#{identifier}".match identifier_pattern
+        raise ::Weskit::WML::Errors::InvalidIdentifier, "Invalid identifier"
+      end
+    end
+
+    def raise_if_missing object, method
+      unless object.respond_to? "#{method}="
+        raise ::Weskit::WML::Errors::InvalidOption, "Object doesn't have #{method}"
+      end
+    end
+
+    private
+
+    def identifier_pattern
+      %r{^[a-z][a-z_0-9]*$}
+    end
+  end
+end

data/lib/weskit/wml/parser.rb

@@ -0,0 +1,47 @@
+require 'polyglot'
+require 'treetop'
+
+require 'open-uri'
+require 'stringio'
+require 'zlib'
+    
+module Weskit::WML
+  class Parser
+    private_class_method :new
+
+    class << self
+      def string str
+        parse str
+      end
+
+      def uri uri
+        begin
+          str = open(uri).read
+        rescue
+          raise Errrors::ReadError, "Coldn't open URI"
+        ensure
+          str = Zlib::GzipReader.new(StringIO.new str).read rescue str
+        end
+
+        parse str
+      end
+
+      private
+
+      def parse data
+        parsed = parser.parse data.strip, :consume_all_input => false
+
+        unless parsed
+          msg = parser.failure_reason or 'Invalid data'
+          raise Errors::ParseError, msg
+        end
+
+        parsed.wml
+      end
+
+      def parser
+        @parser ||= WesnothMarkupLanguageParser.new
+      end
+    end
+  end
+end

data/lib/weskit/wml/root.rb

@@ -0,0 +1,17 @@
+module Weskit::WML
+  class Root < Items
+    include Mixins::Searchable, Mixins::Validator
+
+    def << item
+      raise_unless Item, item
+      (append? item) ? append(item) : add(item)
+      self
+    end
+
+    def find name, nested = false
+      find_elements name, nested
+    end
+
+    alias_method :method_missing, :find
+  end
+end