typedocs 0.0.1

data/lib/typedocs/arguments_spec.rb

@@ -0,0 +1,126 @@
+# Ruby argument pattern:
+# - required* optional* (rest requied*)?
+# - optional+ requied* # optional is matched forward-wise
+#
+# s1 +-opt-> s2 +--req--> s3
+#    |          |
+#    +----------+---------+--rest--> s6 -req-> s7
+#    |         /         /
+#    `-req-> s4 -opt-> s5
+class Typedocs::ArgumentsSpec
+  def initialize
+    # [[type, [spec ...]] ...]
+    @specs = []
+    @current = nil
+  end
+  def empty?
+    @specs.empty?
+  end
+  def valid?(args)
+    matched = match(args)
+    matched && matched.all? {|arg, spec| spec.valid? arg}
+  end
+  def error_message_for(args)
+    matched = match(args)
+    errors = matched.select{|arg, spec|!spec.valid?(arg)}
+    "Expected: #{to_source}. Errors: #{errors.map{|arg,spec|spec.error_message_for(arg)}.join(' ||| ')}"
+  end
+  def to_source
+    @specs.flat_map{|t,s|
+      attr =
+        case t
+        when :req
+          ''
+        when :opt
+          '?'
+        when :res
+          '*'
+        else
+          raise
+        end
+      s.map{|spec| "#{attr}#{spec.to_source}" }
+    }.join(' -> ')
+  end
+  def add_required(arg_spec)
+    _add :req, arg_spec
+  end
+  def add_optional(arg_spec)
+    _add :opt, arg_spec
+  end
+  def add_rest(arg_spec)
+    _add :res, arg_spec
+  end
+  private
+  # args:[...] -> success:[[arg,spec]...] | fail:nil
+  def match(args)
+    args = args.dup
+    types = @specs.map{|t,s|t}
+    case types
+    when [:opt, :req]
+      opt, req = @specs.map{|t,s|s}
+      return nil unless (req.length..(req.length+opt.length)) === args.size
+      args[0...-req.length].zip(opt).to_a + req.zip(args[-req.length..-1]).to_a
+    else
+      # [reqs, opts, rest, reqs]
+      partial = []
+      i = 0
+      if types[i] == :req
+        partial.push @specs[i][1]
+        i += 1
+      else
+        partial.push []
+      end
+      if types[i] == :opt
+        partial.push @specs[i][1]
+        i += 1
+      else
+        partial.push []
+      end
+      if types[i] == :res
+        partial.push @specs[i][1]
+        i += 1
+      else
+        partial.push []
+      end
+      if types[i] == :req
+        partial.push @specs[i][1]
+        i += 1
+      else
+        partial.push []
+      end
+      return nil unless i == types.length
+      reqs, opts, rest, reqs2 = partial
+      raise unless rest.length < 2
+
+      len_min = reqs.length + reqs2.length
+      if rest.empty?
+        len_max = reqs.length + opts.length + reqs2.length
+        return nil unless (len_min..len_max) === args.length
+      else
+        return nil unless len_min <= args.length
+      end
+      reqs_args = args.shift(reqs.length)
+      reqs2_args = args.pop(reqs2.length)
+      opts_args = args.shift([opts.length, args.length].min)
+      rest_args = args
+
+      rest_spec = rest[0]
+      return [
+        *reqs_args.zip(reqs),
+        *opts_args.zip(opts),
+        *(rest_spec ? rest_args.map{|a|[a, rest_spec]} : []),
+        *reqs2_args.zip(reqs2),
+      ]
+    end
+  end
+  def _add(type,spec)
+    Typedocs.ensure_klass(spec, Typedocs::TypeSpec)
+    if @current == type
+      @specs.last[1].push spec
+    else
+      @specs.push [type, [spec]]
+      @current = type
+    end
+  end
+end
+

data/lib/typedocs/block_spec.rb

@@ -0,0 +1,51 @@
+module Typedocs
+  class BlockSpec
+    def initialize(type, name)
+      raise ArgumentError unless [:req, :opt, :none].include?(type)
+      @name = name
+      @type = type
+    end
+    attr_reader :name
+    def valid?(block)
+      case block
+      when nil
+        return @type == :opt || @type == :none
+      when Proc
+        return @type == :opt || @type == :req
+      else
+        raise 'maybe typedocs bug'
+      end
+    end
+    def error_message_for(block)
+      raise ArgumentError if valid?(block)
+      case @type
+      when :req
+        "Block not given"
+      when :none
+        "Block not allowed"
+      else
+        raise 'maybe typedocs bug'
+      end
+    end
+    def to_source
+      n = name
+      case @type
+      when :req
+        "&#{n}"
+      when :opt
+        "?&#{n}"
+      when :none
+        ''
+      else
+        raise "Invalid type: #{@type}"
+      end
+    end
+    def to_source_with_arrow
+      if @type == :none
+        ''
+      else
+        "#{to_source} -> "
+      end
+    end
+  end
+end

data/lib/typedocs/context.rb

@@ -0,0 +1,38 @@
+class Typedocs::Context
+  def self.valid_udt_name?(name)
+    /\A@[A-Z][a-zA-Z0-9]*\Z/ =~ name.to_s
+  end
+
+  def initialize(klass)
+    @klass = klass
+    # udt_name => spec
+    @specs = {}
+  end
+  def typedef(name, definition)
+    raise ArgumentError, "Invalid user-defined type name: #{name}" unless self.class.valid_udt_name?(name)
+    @specs[name.to_s] = Typedocs::Parser.new.parse(@klass, definition, :type)
+  end
+  def defined_type!(name)
+    self_defined_type(name) || outer_defined_type(name) || (raise Typedocs::NoSuchType, "Type not found in #{@klass.name}: #{name}")
+  end
+  def defined_type(name)
+    self_defined_type(name) || outer_defined_type(name) || parent_defined_type(name)
+  end
+  def self_defined_type(name)
+    @specs[name]
+  end
+  def outer_defined_type(name)
+    return nil unless @klass.name
+    outer_name = @klass.name.split(/::/)[0..-2]
+    unless outer_name.empty?
+      outer_klass = outer_name.inject(::Object) {|ns, name| ns.const_get(name) }
+      Typedocs.context(outer_klass).defined_type(name)
+    end
+  end
+  def parent_defined_type(name)
+    return nil unless @kass.kind_of? ::Class
+    superclass = @klass.superclass
+    return nil unless superclass
+    Typedocs.context(superclass).defined_type(name)
+  end
+end

data/lib/typedocs/dsl.rb

@@ -0,0 +1,37 @@
+module Typedocs::DSL
+  def self.included(klass)
+    # doc:String | special:(:inherit) | nil
+    @typedocs_current_def = nil
+
+    class << klass
+      def tdoc(*args)
+        if args.size == 1 && args[0].is_a?(String) || args[0].is_a?(Symbol)
+          @typedocs_current_def = args[0]
+        elsif args.size == 0
+          Typedocs::MultiFunctionalInterface.new(self)
+        else
+          raise ArgumentError
+        end
+      end
+
+      def method_added(name)
+        return unless @typedocs_current_def
+
+        method_spec = ::Typedocs.create_method_spec(self, name, @typedocs_current_def)
+        @typedocs_current_def = nil
+
+        ::Typedocs.define_spec self, name, method_spec
+      end
+
+      def singleton_method_added(name)
+        return unless @typedocs_current_def
+
+        method_spec = ::Typedocs.create_method_spec(self, name, @typedocs_current_def)
+        @typedocs_current_def = nil
+
+        singleton_class = class << self; self; end
+        ::Typedocs.define_spec singleton_class, name, method_spec
+      end
+    end
+  end
+end

data/lib/typedocs/enable.rb

@@ -0,0 +1 @@
+TYPEDOCS_ENABLED = 1

data/lib/typedocs/fallback.rb

@@ -0,0 +1,6 @@
+begin
+  require 'typedocs'
+rescue LoadError
+  require 'typedocs/fallback/impl'
+  Typedocs = TypedocsFallback
+end

data/lib/typedocs/fallback/impl.rb

@@ -0,0 +1,19 @@
+module TypedocsFallback
+  def self.method_missing(name, *args)
+    nil
+  end
+
+  NULL_OBJECT = BasicObject.new
+  def NULL_OBJECT.method_missing(name, *args)
+    self
+  end
+
+  module DSL
+    def self.included(klass)
+      def klass.tdoc(*args)
+        NULL_OBJECT
+      end
+    end
+  end
+end
+

data/lib/typedocs/grammer_printer.rb

@@ -0,0 +1,45 @@
+module Typedocs::GrammerPrinter
+  def self.print_grammer(out)
+    parser = Typedocs::Parser::ASTBuilder.new
+    print_recursive(out, parser.root)
+  end
+
+  def self.print_recursive(out, root)
+    waiting = [root]
+    ignore = {}
+
+    until waiting.empty?
+      entity = waiting.pop
+      next if ignore[entity]
+      ignore[entity] = true
+
+      if entity.kind_of?(Parslet::Atoms::Entity)
+        out.puts "#{'%20s' % entity.to_s} <- #{entity.parslet.to_s.gsub(/[a-z_]+:/, '')}"
+      end
+
+      atoms = Parslet::Atoms
+
+      case entity
+      when atoms::Sequence
+        entity.parslets.reverse.each do|pl|
+          waiting.push pl
+        end
+      when atoms::Lookahead
+        waiting.push entity.bound_parslet
+      when atoms::Repetition
+        waiting.push entity.parslet
+      when atoms::Alternative
+        entity.alternatives.reverse.each do|pl|
+          waiting.push pl
+        end
+      when atoms::Entity
+        waiting.push entity.parslet
+      when atoms::Named
+        waiting.push entity.parslet
+      when atoms::Re, atoms::Str
+      else
+        raise "Unsupported class: #{entity.class}"
+      end
+    end
+  end
+end

data/lib/typedocs/method_spec.rb

@@ -0,0 +1,88 @@
+module Typedocs
+  module MethodSpec
+    class AnyOf
+      # [MethodSpec::Single] ->
+      def initialize(specs)
+        specs.each do|spec|
+          Typedocs.ensure_klass(spec, Typedocs::MethodSpec::Single)
+        end
+        @specs = specs
+      end
+
+      def call_with_validate(method, *args, &block)
+        spec = nil
+        @specs.each do|s|
+          begin
+            s.validate_caller(args, block)
+            spec = s
+            break
+          rescue Typedocs::ArgumentError, Typedocs::BlockError
+          end
+        end
+
+        unless spec
+          raise Typedocs::ArgumentError, "Arguments not match any rule"
+        end
+
+        ret = method.call(*args, &block)
+        spec.validate_retval ret
+        ret
+      end
+
+      def to_source
+        @specs.map(&:to_source).join(' || ')
+      end
+    end
+
+    class Single
+      def initialize(args_spec, block_spec, retval_spec)
+        Typedocs.ensure_klass(args_spec, Typedocs::ArgumentsSpec)
+        Typedocs.ensure_klass(block_spec, Typedocs::BlockSpec)
+        Typedocs.ensure_klass(retval_spec, Typedocs::TypeSpec)
+        @arguments_spec = args_spec
+        @block_spec = block_spec
+        @retval_spec = retval_spec
+      end
+
+      attr_reader :arguments_spec
+      attr_reader :block_spec
+      attr_reader :retval_spec
+
+      def call_with_validate(method, *args, &block)
+        validate_args args
+        validate_block block
+        ret = method.call *args, &block
+        validate_retval ret
+        ret
+      end
+
+      def validate_caller(args, block)
+        validate_args args
+        validate_block block
+      end
+
+      def validate_args(args)
+        raise Typedocs::ArgumentError, arguments_spec.error_message_for(args) unless arguments_spec.valid?(args)
+      end
+
+      def validate_block(block)
+        raise Typedocs::BlockError, "Cant accept block" if !block_spec && block
+        if block_spec
+          raise Typedocs::BlockError, block_spec.error_message_for(block) unless block_spec.valid?(block)
+        end
+      end
+
+      def validate_retval(ret)
+        raise Typedocs::RetValError, retval_spec.error_message_for(ret) unless retval_spec.valid?(ret)
+      end
+
+      def to_source
+        s = ''
+        s << arguments_spec.to_source
+        s << " -> " unless arguments_spec.empty?
+        s << block_spec.to_source_with_arrow
+        s << "#{retval_spec.to_source}"
+      end
+    end
+  end
+end

data/lib/typedocs/multi_functional_interface.rb

@@ -0,0 +1,10 @@
+# -*- coding:utf-8 -*-
+
+class Typedocs::MultiFunctionalInterface
+  def initialize(klass)
+    @klass = klass
+  end
+  def typedef(typename, definition)
+    Typedocs.context(@klass).typedef(typename, definition)
+  end
+end

data/lib/typedocs/parser.rb

@@ -0,0 +1,28 @@
+class Typedocs::Parser; end
+
+require 'typedocs/parser/ast_builder'
+require 'typedocs/parser/object_builder'
+
+class Typedocs::Parser
+  def parse(klass, src, type = :root)
+    ast = Typedocs::Parser::ASTBuilder.new
+    obj = Typedocs::Parser::ObjectBuilder.create_builder_for(klass)
+
+    root = ast.public_send(type)
+
+    result =
+      begin
+        obj.apply root.parse(src)
+      rescue Parslet::ParseFailed => e
+        raise e.cause.ascii_tree
+      rescue ArgumentError => e
+        error = StandardError.new("Parse error: Maybe parser's bug. Input=#{src.inspect}, Error = #{e}")
+        error.set_backtrace e.backtrace
+        raise error
+      end
+    if result.is_a?(Hash)
+      raise "Parse error: Maybe parser's bug or unexpected argument(type: #{type.inspect}). Input=#{src.inspect}, Result=#{result.inspect}"
+    end
+    result
+  end
+end