webidl 0.0.1

data/lib/webidl/ast/scoped_name.rb

@@ -0,0 +1,28 @@
+module WebIDL
+  module Ast
+    class ScopedName < Node
+
+      attr_reader :name
+
+      def initialize(parent, name, opts = {})
+        super(parent)
+
+        @name     = name
+        @relative = !!opts[:relative]
+      end
+
+      def qualified_name
+        if relative? && @parent
+          "#{@parent.qualified_name}::#{@name}"
+        else
+          "::#{@name}"
+        end
+      end
+
+      def relative?
+        @relative
+      end
+
+    end # ScopedName
+  end # Ast
+end # WebIDL

data/lib/webidl/ast/type.rb

@@ -0,0 +1,20 @@
+module WebIDL
+  module Ast
+    class Type < Node
+
+      attr_reader :name
+
+      def initialize(parent, name, opts = {})
+        super(parent)
+
+        @name     = name.strip.to_sym
+        @nullable = !!opts[:nullable]
+      end
+
+      def nullable?
+        @nullable
+      end
+
+    end # Type
+  end # Ast
+end # WebIDL

data/lib/webidl/ast/typedef.rb

@@ -0,0 +1,15 @@
+module WebIDL
+  module Ast
+    class TypeDef < Node
+
+      attr_reader :type, :name
+
+      def initialize(parent, type, name)
+        @parent = parent
+        @type   = type
+        @name   = name
+      end
+
+    end # TypeDef
+  end # Ast
+end # WebIDL

data/lib/webidl/extensions/string.rb

@@ -0,0 +1,22 @@
+class String
+  #
+  # Convert from camel case to snake case
+  #
+  #     'FooBar'.snake_case # => "foo_bar"
+  #
+
+  def snake_case
+    gsub(/\B[A-Z][^A-Z]/, '_\&').downcase.gsub(' ', '_')
+  end
+
+  #
+  # Convert from snake case to camel case
+  #
+  #     'foo_bar'.camel_case # => "FooBar"
+  #
+
+  def camel_case
+   split('_').map { |e| e.capitalize }.join
+  end
+
+end

data/lib/webidl/extensions/syntax_node.rb

@@ -0,0 +1,5 @@
+class Treetop::Runtime::SyntaxNode
+  def any?
+    !empty?
+  end
+end

data/lib/webidl/generator.rb

@@ -0,0 +1,38 @@
+require "webidl/generator/ruby_sexp_visitor"
+module WebIDL
+  class Generator
+
+    class ParseError < StandardError; end
+
+    def initialize(visitor = nil)
+      @visitor = visitor
+    end
+
+    def generate(str)
+      parse_tree = parser.parse(str)
+
+      if parse_tree.nil?
+        raise ParseError, parser.failure_reason
+      end
+
+      ast_defs = parse_tree.build
+      strings = ast_defs.map { |definition| ruby2ruby.process definition.accept(visitor) }
+      strings.join("\n\n")
+    end
+
+    private
+
+    def ruby2ruby
+      @ruby2ruby ||= Ruby2Ruby.new
+    end
+
+    def parser
+      @parser ||= WebIDL::Parser::IDLParser.new
+    end
+
+    def visitor
+      @visitor ||= RubySexpVisitor.new
+    end
+
+  end # Generator
+end # WebIDL

data/lib/webidl/generator/ruby_sexp_visitor.rb

@@ -0,0 +1,118 @@
+module WebIDL
+  class RubySexpVisitor
+
+    def visit_module(mod)
+      [:block,
+        [:module, classify(mod.name),
+          [:scope,
+            [:block] + mod.definitions.map { |d| d.accept(self) }
+          ]
+        ]
+      ]
+    end
+
+    def visit_interface(intf)
+      [:module, classify(intf.name),
+        ([:scope, [:block] + intf.inherits.map { |inherit| [:call, nil, :include, [:arglist, inherit.accept(self)]] }] unless intf.inherits.empty?),
+        [:scope,
+          [:block] + intf.members.map { |m| m.accept(self) }
+        ]
+      ].compact
+    end
+
+    def visit_exception(ex)
+      [:class, classify(ex.name), [:const, :StandardError],
+        [:scope,
+          [:block] + ex.members.map { |m| m.accept(self)}
+        ]
+      ]
+    end
+
+    def visit_const(const)
+      [:cdecl, const.name, [:lit, const.value]] # FIXME: won't always be literals - need Literal AST node?
+    end
+
+    def visit_field(field)
+      [:call, nil, :attr_accessor, [:arglist, [:lit, field.name.to_sym]]]
+    end
+
+    def visit_attribute(attribute)
+      func = attribute.readonly? ? :attr_reader : :attr_accessor
+      [:call, nil, func, [:arglist, [:lit, attribute.name.snake_case.to_sym]]]
+    end
+
+    def visit_operation(operation)
+      if operation.name.empty?
+        if operation.setter?
+          meth = :[]=
+        elsif operation.getter?
+          meth = :[]
+        elsif operation.creator?
+          meth = :initialize
+        elsif operation.stringifier?
+          meth = :to_s
+        elsif operation.deleter?
+          meth = :delete!
+        else
+          raise "no name for operation #{operation.pretty_inspect}"
+        end
+      else
+        meth = operation.name.snake_case
+        meth << "=" if operation.setter?
+      end
+
+      [:defn, meth.to_sym,
+        [:args] + operation.args.map { |a| a.accept(self) },
+        [:scope,
+          [:block,
+            [:call, nil, :raise,
+              [:arglist,
+                [:const, :NotImplementedError]
+              ]
+            ]
+          ]
+        ]
+      ]
+    end
+
+    def visit_argument(argument)
+      name = argument.name.snake_case
+      arg = argument.variadic? ? "*#{name}" : name
+
+      arg.to_sym
+    end
+
+    def visit_type_def(typedef)
+      # don't care
+    end
+
+    def visit_implements_statement(impls)
+      [:module, classify(impls.implementor),
+        [:scope,
+          [:call, nil, :include,
+            [:arglist,
+              [:const, classify(impls.implementee)]
+            ]
+          ]
+        ]
+      ]
+    end
+
+    def visit_scoped_name(sn)
+      [:const, classify(sn.qualified_name)]
+    end
+
+    private
+
+    def classify(string)
+      s = string.to_s
+
+      if s.include?("::")
+        s.split("::").map { |e| classify(e) unless e.empty? }.compact.join("::").to_sym
+      else
+        "#{s.slice(0,1).upcase}#{s[1..-1]}".to_sym
+      end
+    end
+
+  end # RubySexpVisitor
+end # WebIDL

data/lib/webidl/parse_tree/absolute_scoped_name.rb

@@ -0,0 +1,11 @@
+module WebIDL
+  module ParseTree
+    class AbsoluteScopedName < Treetop::Runtime::SyntaxNode
+
+      def build(parent)
+        raise NotImplementedError
+      end
+
+    end # RelativeScopedName
+  end # ParseTree
+end # WebIDL

data/lib/webidl/parse_tree/argument.rb

@@ -0,0 +1,20 @@
+module WebIDL
+  module ParseTree
+    class Argument < Treetop::Runtime::SyntaxNode
+
+      def build(parent)
+        arg = Ast::Argument.new(
+          id.build,
+          type.build(parent),
+          :optional => optional.any?,
+          :variadic => variadic.any?
+        )
+
+        arg.extended_attributes = eal.build unless eal.empty?
+
+        arg
+      end
+
+    end # Argument
+  end # ParseTree
+end # WebIDL

data/lib/webidl/parse_tree/argument_list.rb

@@ -0,0 +1,14 @@
+module WebIDL
+  module ParseTree
+    class ArgumentList < Treetop::Runtime::SyntaxNode
+
+      def build(parent)
+        list = [arg.build(parent)]
+        list += args.build(parent) unless args.empty?
+
+        list
+      end
+
+    end # ArgumentList
+  end # ParseTree
+end # WebIDL

data/lib/webidl/parse_tree/attribute.rb

@@ -0,0 +1,17 @@
+module WebIDL
+  module ParseTree
+    class Attribute < Treetop::Runtime::SyntaxNode
+
+      def build(parent)
+        options = {
+          :readonly  => readonly.any?,
+          :getraises => (getraises.build unless getraises.empty?),
+          :setraises => (setraises.build unless setraises.empty?)
+        }
+
+        Ast::Attribute.new parent, type.build(parent), name.build, options
+      end
+
+    end # Attribute
+  end # ParseTree
+end # WebIDL

data/lib/webidl/parse_tree/const.rb

@@ -0,0 +1,9 @@
+module WebIDL
+  module ParseTree
+    class Const < Treetop::Runtime::SyntaxNode
+      def build(parent)
+        Ast::Const.new(parent, type.build(parent), name.text_value, const_expr.build)
+      end
+    end # Const
+  end # ParseTree
+end # WebIDL

data/lib/webidl/parse_tree/definitions.rb

@@ -0,0 +1,25 @@
+module WebIDL
+  module ParseTree
+    class Definitions < Treetop::Runtime::SyntaxNode
+
+      def build(parent = nil)
+        return [] if metadef.empty?
+
+        unless metadef.d.empty?
+          definition = metadef.d.build(parent)
+          definition.extended_attributes = metadef.eal.build(parent) unless metadef.eal.empty?
+        end
+
+        result = [definition]
+        result += metadef.defs.build(parent) unless metadef.defs.empty?
+
+        if parent
+          parent.definitions = result
+        end
+
+        result.compact
+      end
+
+    end # Definitions
+  end # ParseTree
+end # WebIDL

data/lib/webidl/parse_tree/exception.rb

@@ -0,0 +1,15 @@
+module WebIDL
+  module ParseTree
+    class Exception < Treetop::Runtime::SyntaxNode
+
+      def build(parent)
+        ex = Ast::Exception.new(parent, name.text_value)
+
+        members.build(ex) unless members.empty?
+
+        ex
+      end
+
+    end # Exception
+  end # ParseTree
+end # WebIDL

data/lib/webidl/parse_tree/exception_field.rb

@@ -0,0 +1,11 @@
+module WebIDL
+  module ParseTree
+    class ExceptionField < Treetop::Runtime::SyntaxNode
+
+      def build(parent)
+        Ast::Field.new(parent, type.build(parent), id.text_value)
+      end
+
+    end # ExceptionField
+  end # ParseTree
+end # WebIDL

data/lib/webidl/parse_tree/extended_attributes.rb

@@ -0,0 +1,41 @@
+module WebIDL
+  module ParseTree
+
+    class ExtendedAttributeList < Treetop::Runtime::SyntaxNode
+      def build(parent)
+        list = [attribute.build(parent)]
+        list += attributes.build(parent) unless attributes.empty?
+
+        list
+      end
+    end
+
+    class ExtendedAttributeArgList < Treetop::Runtime::SyntaxNode
+      def build(parent)
+        unless args.empty?
+          arguments = args.build(parent)
+        end
+        Ast::ExtendedAttribute.new(name.text_value, arguments)
+      end
+    end
+
+    class ExtendedAttributeIdent < Treetop::Runtime::SyntaxNode
+      def build(parent)
+        [key, value].map { |e| e.text_value }
+      end
+    end
+
+    class ExtendedAttributeNamedArgList < Treetop::Runtime::SyntaxNode
+      def build(parent)
+        [key.text_value, value.build(parent)]
+      end
+    end
+
+    class ExtendedAttributeScopedName < Treetop::Runtime::SyntaxNode
+      def build(parent)
+        [key.text_value, scoped_name.build(parent)]
+      end
+    end
+
+  end # ParseTree
+end # WebIDL

data/lib/webidl/parse_tree/implements_statement.rb

@@ -0,0 +1,20 @@
+module WebIDL
+  module ParseTree
+    class ImplementsStatement < Treetop::Runtime::SyntaxNode
+
+      def build(parent)
+        # not sure how this should be handled
+        # currently keep a global list of interfaces, find the implementor and put the implementee in its 'implements' list
+        # perhaps this is too early to do the resolving?
+        implor_name = implementor.build(parent).qualified_name
+        implee_name = implementee.build(parent).qualified_name
+
+        # implor = Ast::Interface.list[implor_name]
+        # implee = Ast::Interface.list[implee_name]
+
+        Ast::ImplementsStatement.new(parent, implor_name, implee_name)
+      end
+
+    end # ImplementsStatement
+  end # ParseTree
+end # WebIDL