weskit 0.0.2 → 0.1.0

data/lib/weskit/mp/worker.rb

@@ -0,0 +1,35 @@
+require 'forwardable'
+
+module Weskit::MP
+  class Worker
+    extend Forwardable
+
+    attr_reader :debug, :nickname
+    def_delegators :@connection, :message, :read, :write
+
+    def connect_and &operate
+      @connection.open do
+        instance_eval &operate
+      end
+    end
+
+    def initialize nickname
+      @connection = Connection.new self
+      @nickname   = nickname
+    end
+
+    def login
+      message 'login', {:selective_ping => 1, :username => @nickname}
+      read ; verify_response :mustlogin
+      read ; verify_response :join_lobby
+    end
+
+    def verify_response element
+      element = @connection.buffer.find(element).first
+
+      unless element
+        raise Errors::ResponseError, "Server send node other than '#{element}'"
+      end
+    end
+  end
+end

data/lib/weskit/mp.rb

@@ -0,0 +1,13 @@
+require 'weskit/version'
+require 'weskit/wml'
+
+module Weskit
+  module MP
+  end
+end
+
+require 'weskit/mp/errors/error'
+require 'weskit/mp/errors/response_error'
+require 'weskit/mp/adapter'
+require 'weskit/mp/connection'
+require 'weskit/mp/worker'

data/lib/weskit/version.rb

@@ -1,3 +1,3 @@
 module Weskit
-  VERSION = "0.0.2"
+  VERSION = '0.1.0'
 end

data/lib/weskit/wml/attribute.rb

@@ -0,0 +1,65 @@
+require 'observer'
+
+module Weskit::WML
+  class Attribute < Item
+    include Observable
+
+    attachable_to :element
+
+    attr_reader :value
+
+    def code= bool
+      @code = bool ? (@translatable = false ; true) : false
+    end
+
+    def code?
+      @code
+    end
+
+    def multiline?
+      "#{value}".include? "\n"
+    end
+
+    def text?
+      code? or multiline? or translatable?
+    end
+
+    def translatable= bool
+      @translatable = bool ? (@code = false ; true) : false
+    end
+
+    def translatable?
+      @translatable
+    end
+
+    def initialize name, value, defaults = {}
+      @code = @translatable = false
+
+      self.name  = name
+      self.value = value
+
+      merge defaults
+    end
+
+    def value= object
+      @value = convert object
+    end
+
+    private
+
+    def convert object
+      string = object.to_s.strip
+
+      object = case string
+        when %r{^nil|null$}       then nil
+        when %r{^true|yes$}       then true
+        when %r{^false|no$}       then false
+        when %r{^[0-9]*\.[0-9]+$} then Float string
+        when %r{^[0-9]+$}         then Integer string
+        else string
+      end
+
+      object.attr = self ; object
+    end
+  end
+end

data/lib/weskit/wml/attributes.rb

@@ -0,0 +1,16 @@
+module Weskit::WML
+  class Attributes < Items
+    undef_method :attrs, :attributes
+    undef_method :elems, :elements
+
+    def [] name
+      name = ::Weskit::WML::Item.identifier name
+      attribute(name).value
+    end
+
+    def << item
+      append_attribute item
+      self
+    end
+  end
+end

data/lib/weskit/wml/builder.rb

@@ -0,0 +1,66 @@
+module Weskit::WML
+  class Builder
+    private_class_method :new
+
+    def attribute name, value, defaults = nil
+      a = Attribute.new name, value, defaults || {}
+      @built << a ; a
+    end
+
+    def create &contents
+      instance_eval &contents ; @built
+    end
+
+    def element name, defaults = nil
+      e = Element.new name, defaults || {}
+      @built << e ; e
+    end
+
+    def id value
+      attribute :id, value
+    end
+
+    def initialize
+      @built = []
+    end
+
+    def method_missing *params
+      p = params
+      unless block_given?
+        raise_invalid_count if p.size < 2
+        attribute p[0], p[1], p[2]
+      else
+        raise_invalid_count if p.size < 1
+        element(p[0], p[1]).build &Proc.new
+      end
+    end
+
+    private
+
+    def raise_invalid_count
+      raise Errors::InvalidParameters, "Invalid number of parameters"
+    end
+
+    class << self
+      def build &contents
+        new.create &contents
+      end
+
+      def convert hash
+        root = Root.new
+
+        hash.each do |k, v|
+          if v.is_a? Hash
+            e = Element.new k
+            e.push *Builder.convert(v)
+            root << e
+          else
+            root << Attribute.new(k, v)
+          end
+        end
+
+        root
+      end
+    end
+  end
+end

data/lib/weskit/wml/element.rb

@@ -0,0 +1,34 @@
+module Weskit::WML
+  class Element < Item
+    include Mixins::Container, Mixins::Searchable, Mixins::Validator
+
+    attachable_to :parent
+    
+    attr_reader :contents
+
+    def << item
+      (append? item) ? append(item) : add(item)
+      item.attach_to self
+      self
+    end
+
+    def amendment= bool
+      @amendment = bool ? true : false
+    end
+
+    def amendment?
+      @amendment
+    end
+
+    def find name, nested = false
+      find_elements name, nested
+    end
+
+    alias_method :method_missing, :find
+
+    def initialize name, defaults = {}
+      @amendment, @contents = false, []
+      super
+    end
+  end
+end

data/lib/weskit/wml/elements.rb

@@ -0,0 +1,27 @@
+module Weskit::WML
+  class Elements < Items
+    include Mixins::Container, Mixins::Searchable
+
+    undef_method :attrs, :attributes
+    undef_method :elems, :elements
+
+    def [] key
+      case key
+        when Integer then contents[key]
+        else contents[0][key] rescue nil
+      end
+    end
+
+    def << item
+      raise_unless Element, item
+      item.amendment? ? append(item) : add(item)
+      self
+    end
+
+    def find name, nested = true
+      find_elements name, nested
+    end
+
+    alias_method :method_missing, :find
+  end
+end

data/lib/weskit/wml/errors/error.rb

@@ -0,0 +1,3 @@
+module Weskit::WML::Errors
+  class Error < StandardError ; end
+end

data/lib/weskit/wml/errors/invalid_identifier.rb

@@ -0,0 +1,3 @@
+module Weskit::WML::Errors
+  class InvalidIdentifier < ::Weskit::WML::Errors::Error ; end
+end

data/lib/weskit/wml/errors/invalid_item.rb

@@ -0,0 +1,3 @@
+module Weskit::WML::Errors
+  class InvalidItem < ::Weskit::WML::Errors::Error ; end
+end

data/lib/weskit/wml/errors/invalid_option.rb

@@ -0,0 +1,3 @@
+module Weskit::WML::Errors
+  class InvalidOption < ::Weskit::WML::Errors::Error ; end
+end

data/lib/weskit/wml/errors/invalid_parameters.rb

@@ -0,0 +1,3 @@
+module Weskit::WML::Errors
+  class InvalidParameters < ::Weskit::WML::Errors::Error ; end
+end

data/lib/weskit/wml/errors/parse_error.rb

@@ -0,0 +1,3 @@
+module Weskit::WML::Errors
+  class ParseError < ::Weskit::WML::Errors::Error ; end
+end

data/lib/weskit/wml/errors/read_error.rb

@@ -0,0 +1,3 @@
+module Weskit::WML::Errors
+  class ReadError < ::Weskit::WML::Errors::Error ; end
+end

data/lib/weskit/wml/extensions/object.rb

@@ -0,0 +1,19 @@
+class Object
+  include ::Weskit::WML::Mixins::Validator
+
+  attr_reader :attribute
+
+  alias_method :attr,  :attribute
+
+  def attribute= item
+    @attribute = item ? (raise_unless ::Weskit::WML::Attribute, item ; item) : nil
+  end
+
+  alias_method :attr=, :attribute=
+
+  def attribute?
+    @attribute ? true : false
+  end
+
+  alias_method :attr?, :attribute?
+end

data/lib/weskit/wml/formatter.rb

@@ -0,0 +1,82 @@
+module Weskit::WML
+  class Formatter
+    private_class_method :new
+
+    attr_reader :separator
+
+    def format item, indentation = 0
+      case item
+        when Attribute then @attr_formatter.format item, indentation
+        when Element   then @elem_formatter.format item, indentation
+      end
+    end
+
+    def format_detached item, formatter = nil
+      formatter ||= item.formatter
+      duplicate   = item.dup.detach
+
+      duplicate.formatter = formatter
+      format item
+    end
+
+    def indent content, width = 0
+      @indent * width + "#{content}"
+    end
+
+    def initialize options = {}
+      options = options_default.merge options
+
+      @attr_formatter = options[:attr_formatter].new self
+      @elem_formatter = options[:elem_formatter].new self
+
+      @indent    = options[:indent]
+      @separator = options[:separator]
+
+      self
+    end
+
+    private
+
+    def options_default
+      {
+        :indent    => '  ',
+        :separator => $/
+      }
+    end
+
+    class << self
+      def color
+        @color ||= new options_color
+      end
+
+      def default
+        @default or plain
+      end
+
+      def default= item
+        Mixins::Validator.raise_unless Formatter, item
+        @default = item
+      end
+
+      def plain
+        @plain ||= new options_plain
+      end
+
+      private
+
+      def options_color
+        {
+          :attr_formatter => Formatters::AnsiColorAttribute,
+          :elem_formatter => Formatters::AnsiColorElement
+        }
+      end
+
+      def options_plain
+        {
+          :attr_formatter => Formatters::Attribute,
+          :elem_formatter => Formatters::Element
+        }
+      end
+    end
+  end
+end

data/lib/weskit/wml/formatters/ansi_color.rb

@@ -0,0 +1,49 @@
+require 'term/ansicolor'
+
+module Weskit::WML::Formatters
+  module AnsiColor
+    module_function
+
+    private
+
+    def ac
+      Term::ANSIColor
+    end
+
+    def reset
+      ac.reset
+    end
+
+    def attribute text
+      "#{attribute_color}#{text}#{reset}"
+    end
+
+    def attribute_color
+      ac.yellow
+    end
+
+    def val text
+      "#{value_color}#{text}#{reset}"
+    end
+
+    def val_color
+      ac.intense_cyan
+    end
+
+    def control text
+      "#{control_color}#{text}#{reset}"
+    end
+
+    def control_color
+      ac.intense_blue
+    end
+
+    def element text
+      "#{element_color}#{text}#{reset}"
+    end
+
+    def element_color
+      ac.intense_green
+    end
+  end
+end

data/lib/weskit/wml/formatters/ansi_color_attribute.rb

@@ -0,0 +1,31 @@
+module Weskit::WML::Formatters
+  class AnsiColorAttribute < Attribute
+    include ::Weskit::WML::Formatters::AnsiColor
+
+    private
+
+    def defaults
+      hash = super
+
+      hash[:assignment] = control hash[:assignment]
+      hash[:code_start] = control hash[:code_start]
+      hash[:code_end]   = control hash[:code_end]
+      hash[:quote]      = control hash[:quote]
+      hash[:underscore] = control hash[:underscore]
+
+      hash
+    end
+
+    def escape_sequence
+      reset + "#{@quote * 2}" + val_color
+    end
+
+    def text attribute
+      val_color + "#{attribute.value}" + reset
+    end
+
+    def name attribute
+      attribute super
+    end
+  end
+end

data/lib/weskit/wml/formatters/ansi_color_element.rb

@@ -0,0 +1,22 @@
+module Weskit::WML::Formatters
+  class AnsiColorElement < Element
+    include  ::Weskit::WML::Formatters::AnsiColor
+
+    private
+
+    def defaults
+      hash = super
+
+      hash[:amend_char]   = control hash[:amend_char]
+      hash[:closing_char] = control hash[:closing_char]
+      hash[:closing]      = control hash[:closing]
+      hash[:opening]      = control hash[:opening]
+
+      hash
+    end
+
+    def name element
+      element super
+    end
+  end
+end

data/lib/weskit/wml/formatters/attribute.rb

@@ -0,0 +1,62 @@
+module Weskit::WML::Formatters
+  class Attribute < ItemFormatter
+    def format attribute, indent = 0
+      content = "#{name attribute}#@assignment#{value attribute}"
+      @formatter.indent content, indent
+    end
+
+    private
+
+    def defaults
+      {
+        :assignment => '=',
+        :code_start => '<<',
+        :code_end   => '>>',
+        :quote      => '"',
+        :underscore => '_'
+      }
+    end
+
+    def escape value
+      value.gsub @quote, escape_sequence
+    end
+
+    def escape_sequence
+      @quote * 2
+    end
+
+    def text attribute
+      "#{attribute.value}"
+    end
+
+    def name attribute
+      "#{attribute.name}"
+    end
+
+    def code_value attribute
+      "#@code_start#{text attribute}#@code_end"
+    end
+
+    def raw_value attribute
+      text attribute
+    end
+
+    def text_value attribute
+      string = escape text attribute
+      string = "#@quote#{string}#@quote"
+      string = "#@underscore#{string}" if attribute.translatable?
+    end
+
+    def value attribute
+      method = if attribute.code?
+        :code_value
+      elsif attribute.text?
+        :text_value
+      else
+        :raw_value
+      end
+
+      send method, attribute
+    end
+  end
+end

data/lib/weskit/wml/formatters/element.rb

@@ -0,0 +1,44 @@
+module Weskit::WML::Formatters
+  class Element < ItemFormatter
+    def format element, indent = 0
+      contents = []
+
+      contents.push @formatter.indent(opening_tag(element), indent)
+      contents += element.contents.collect {|i| @formatter.format i, indent + 1}
+      contents.push @formatter.indent(closing_tag(element), indent)
+
+      contents.join @formatter.separator
+    end
+
+    private
+
+    def defaults
+      {
+        :amend_char   => '+',
+        :closing_char => '/',
+        :closing      => ']',
+        :opening      => '['
+      }
+    end
+
+    def closing_tag element
+      tag "#@closing_char#{name element}"
+    end
+
+    def name element
+      "#{element.name}"
+    end
+
+    def opening_prefix element
+      element.amendment? ? "#@amend_char" : ''
+    end
+
+    def opening_tag element
+      tag "#{opening_prefix element}#{name element}"
+    end
+
+    def tag content
+      "#@opening#{content}#@closing"
+    end
+  end
+end

data/lib/weskit/wml/formatters/item_formatter.rb

@@ -0,0 +1,17 @@
+module Weskit::WML::Formatters
+  class ItemFormatter
+    include ::Weskit::WML::Mixins::Validator
+
+    def initialize item
+      raise_unless  ::Weskit::WML::Formatter, item
+      set_instance_variables
+      @formatter = item
+    end
+
+    private
+
+    def set_instance_variables
+      defaults.each {|var, value| instance_variable_set "@#{var}", value}
+    end
+  end
+end