vue_component_compiler 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9c4f7b83e30ac6e415fc1d356d67f6da85b377682b5de1813a31e2ccd2160d78
+  data.tar.gz: fe4f450d390c613c09b21062c159879ed88ac5573ac04747dd89086b7d08466e
+SHA512:
+  metadata.gz: 320dea5c591312eb4fbbdebc695296e2d485b78f6d4f24d90b88db744736cb44548ff114cb96689878e5a9ae588a5ba915cc9933774abb4ce0da9ebeb33123aa
+  data.tar.gz: 60a0086f3d387c73afe65ddb0e3a252d4373fb65e5b6c6ef70f2f5ceb213eb521129a42ddb50c4f224778d2143365fbd7a432e46d76c4bbfed75580a1fd506e4

data/.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true

data/.gitignore

@@ -0,0 +1,4 @@
+*.vue
+*.gem
+.rspec_status
+Gemfile.lock

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.5

data/Gemfile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+gem "rake", "~> 12.3"
+
+group :test do
+  gem "rspec", "~> 3.8"
+end

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018-present Pig Fang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,9 @@
+# Vue Component Compiler
+
+Vue component compiler written in Ruby. It's still experimental.
+
+Unlike other gems, this compiler doesn't require V8, because it's written in pure Ruby.
+
+## License
+
+MIT Licens (c) 2018-present Pig Fang

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/vue_component_compiler.rb

@@ -0,0 +1,14 @@
+require 'vue_component_compiler/token'
+require 'vue_component_compiler/tokenizer'
+require 'vue_component_compiler/node'
+require 'vue_component_compiler/parser'
+
+module VueCompiler
+  def parse(code)
+    tokenizer = Tokenizer.new(code)
+    parser = Parser.new(tokenizer.tokenize)
+    parser.parse
+  end
+
+  module_function :parse
+end

data/lib/vue_component_compiler/node.rb

@@ -0,0 +1,108 @@
+module VueCompiler
+  module Node
+    class Program
+      attr_reader :children, :comments
+
+      def initialize(children, comments = [])
+        @children = children
+        @comments = comments
+      end
+    end
+
+    class Comment
+      attr_reader :body
+
+      def initialize(body)
+        @body = body
+      end
+    end
+
+    class Element
+      attr_reader :name, :attributes, :children
+
+      def initialize(name, attributes = [], children = [])
+        @name = name
+        @attributes = attributes
+        @children = children
+      end
+    end
+
+    class Text
+      attr_reader :content
+
+      def initialize(content)
+        @content = content
+      end
+    end
+
+    class Interpolation
+      attr_reader :expression
+
+      def initialize(expression)
+        @expression = expression
+      end
+    end
+
+    class Attribute
+      attr_reader :name, :value
+
+      def initialize(name, value)
+        @name = name
+        @value = value
+      end
+    end
+
+    class AttributeName
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+    end
+
+    class Directive
+      attr_reader :name, :argument, :shorthand
+
+      def initialize(name, argument, shorthand = false)
+        @name = name
+        @argument = argument
+        @shorthand = shorthand
+      end
+    end
+
+    class AttributeValue
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+      end
+    end
+
+    class TemplateBlock
+      attr_reader :body
+
+      def initialize(body)
+        @body = body
+      end
+    end
+
+    class ScriptBlock
+      attr_reader :content, :lang
+
+      def initialize(content, lang = 'js')
+        @content = content
+        @lang = lang
+      end
+    end
+
+    class StyleBlock
+      attr_reader :content, :lang, :scoped
+
+      def initialize(content, lang = 'css', scoped = false)
+        @content = content
+        @lang = lang
+        @scoped = scoped
+      end
+    end
+  end
+end

data/lib/vue_component_compiler/parser.rb

@@ -0,0 +1,181 @@
+module VueCompiler
+  class Parser
+    DIRECTIVE_RE = /v\-(\w+)(?:\:(\w+))?/
+
+    # @param tokens {Array}
+    def initialize(tokens)
+      @tokens = tokens
+      @comments = []
+    end
+
+    def parse
+      root_children = []
+
+      until @tokens[0].instance_of?(Token::EndOfSource)
+        token = @tokens[0]
+        if token.instance_of?(Token::ScriptBlock)
+          token = self.eat
+          root_children << Node::ScriptBlock.new(
+            token.content,
+            token.lang
+          )
+          next
+        elsif token.instance_of?(Token::StyleBlock)
+          token = self.eat
+          root_children << Node::StyleBlock.new(
+            token.content,
+            token.lang,
+            token.scoped
+          )
+          next
+        elsif token.instance_of?(Token::CommentStart)
+          self.parse_comment
+          next
+        elsif token.instance_of?(Token::CustomBlock)
+          root_children << token
+          self.eat
+          next
+        end
+
+        self.expect(Token::OpenTagStart)
+        self.expect(Token::OpenTagName)
+        self.expect(Token::TagEnd)
+
+        while token.instance_of?(Token::CommentStart)
+          self.parse_comment
+        end
+
+        if @tokens[0].instance_of?(Token::OpenTagStart)
+          element = Node::Element.new(
+            'template',
+            [],
+            [self.parse_element]
+          )
+          root_children << Node::TemplateBlock.new(element)
+        end
+
+        while token.instance_of?(Token::CommentStart)
+          self.parse_comment
+        end
+
+        self.expect(Token::ClosingTagStart)
+        self.expect(Token::ClosingTagName)
+        self.expect(Token::TagEnd)
+      end
+
+      Node::Program.new(root_children, @comments)
+    end
+
+    def eat
+      @tokens.shift
+    end
+
+    def expect(token)
+      if @tokens[0].instance_of?(token)
+        @tokens.shift
+      else
+        raise Exception.new("Found token type #{@tokens[0].class}, expecting #{token}")
+      end
+    end
+
+    def parse_comment
+      self.eat
+      @comments << Node::Comment.new(self.eat.value)
+      self.eat
+    end
+
+    def parse_element
+      self.expect(Token::OpenTagStart)
+      tag_name = self.expect(Token::OpenTagName).name
+      attributes = []
+
+      while @tokens[0].instance_of?(Token::AttributeName)
+        attributes << self.parse_attribute
+      end
+
+      if self.eat.instance_of?(Token::SelfClosingTag)
+        return Node::Element.new(tag_name, attributes)
+      end
+
+      children = self.parse_element_children
+
+      self.expect(Token::ClosingTagStart)
+      self.expect(Token::ClosingTagName)
+      self.expect(Token::TagEnd)
+
+      Node::Element.new(tag_name, attributes, children)
+    end
+
+    def parse_attribute
+      name = self.eat.name
+      value = nil
+
+      if @tokens[0].instance_of?(Token::AttributeValue)
+        value = self.eat.value
+      end
+
+      if name.start_with?(':')
+        if value
+          Node::Attribute.new(
+            Node::Directive.new('bind', name[1..-1], true),
+            Node::AttributeValue.new(value)
+          )
+        else
+          raise Exception.new('Missing value of `v-bind` directive.')
+        end
+      elsif name.start_with?('@')
+        if value
+          Node::Attribute.new(
+            Node::Directive.new('on', name[1..-1], true),
+            Node::AttributeValue.new(value)
+          )
+        else
+          raise Exception.new('Missing value of `v-on` directive.')
+        end
+      elsif name.start_with?('v-')
+        matched = name.match(DIRECTIVE_RE)
+        name = matched[1]
+        argument = matched[2]
+        Node::Attribute.new(
+          Node::Directive.new(name, argument),
+          Node::AttributeValue.new(value)
+        )
+      else
+        Node::Attribute.new(
+          Node::AttributeName.new(name),
+          Node::AttributeValue.new(value)
+        )
+      end
+    end
+
+    def parse_element_children
+      children = []
+
+      until @tokens[0].instance_of?(Token::ClosingTagStart)
+        token = @tokens[0]
+
+        if token.instance_of?(Token::OpenTagStart)
+          children << self.parse_element
+        elsif token.instance_of?(Token::Text)
+          children << Node::Text.new(self.eat.content)
+        elsif token.instance_of?(Token::InterpolationStart)
+          children << self.parse_interpolation
+        elsif token.instance_of?(Token::CommentStart)
+          self.parse_comment
+        else
+          raise Exception.new('Unknown token type.')
+        end
+      end
+
+      children
+    end
+
+    def parse_interpolation
+      self.eat
+      interpolation = Node::Interpolation.new(self.eat.expression)
+      self.eat
+
+      interpolation
+    end
+  end
+end

data/lib/vue_component_compiler/token.rb

@@ -0,0 +1,105 @@
+module VueCompiler
+  module Token
+    class EndOfSource end
+
+    class CommentStart end
+
+    class Comment
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+      end
+    end
+
+    class CommentEnd end
+
+    class OpenTagStart end
+
+    class ClosingTagStart end
+
+    class TagEnd end
+
+    class SelfClosingTag end
+
+    class TagName
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+    end
+
+    class OpenTagName < TagName
+    end
+
+    class ClosingTagName < TagName
+    end
+
+    class AttributeName
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+    end
+
+    class AttributeValue
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+      end
+    end
+
+    class Text
+      attr_reader :content
+
+      def initialize(content)
+        @content = content
+      end
+    end
+
+    class InterpolationStart
+    end
+
+    class Interpolation
+      attr_reader :expression
+
+      def initialize(expression)
+        @expression = expression
+      end
+    end
+
+    class InterpolationEnd
+    end
+
+    class ScriptBlock
+      attr_reader :content, :lang
+
+      def initialize(content, lang = 'js')
+        @content = content
+        @lang = lang
+      end
+    end
+
+    class StyleBlock
+      attr_reader :content, :lang, :scoped
+
+      def initialize(content, lang = 'css', scoped = false)
+        @content = content
+        @lang = lang
+        @scoped = scoped
+      end
+    end
+
+    class CustomBlock
+      attr_reader :type, :attributes, :content
+
+      def initialize(type, content, attributes = {})
+        @type = type
+        @content = content
+      end
+    end
+  end
+end

data/lib/vue_component_compiler/tokenizer.rb

@@ -0,0 +1,322 @@
+module VueCompiler
+  class Tokenizer
+    TAG_RE = /^[a-z][a-z0-9:-]*/
+    TAG_NAME_RE = /^[a-z][a-z0-9:-]*/
+    ATTRIBUTE_NAME_RE = /^[a-z0-9@:\-]+/
+    ATTRIBUTE_VALUE_RE = /^"([^"\r\n]*)"|'([^'\r\n]*)'|([^\s\r\n\t<>'"]+)/
+    WHITESPACE_RE = /^[\s\n\t\r]+/
+    QUOTE_RE = /^'|"/
+
+    VOID_TAG = %w(area base br col command embed hr img input keygen link meta param source track wbr)
+
+    # @param code {String}
+    def initialize(code)
+      @code = code.delete_prefix("\uFEFF")
+      @tokens = []
+    end
+
+    def tokenize
+      while @code && !@code.empty?
+        if @code.start_with?('<template')
+          self.scan_top_level_template
+        elsif @code =~ WHITESPACE_RE
+          self.eat_whitespaces
+        elsif @code.start_with?('<script')
+          self.scan_script_block
+        elsif @code.start_with?('<style')
+          self.scan_style_block
+        elsif @code.start_with?('<!--')
+          self.scan_comment
+        elsif @code =~ TAG_RE
+          self.scan_custom_block
+        end
+      end
+      @tokens << Token::EndOfSource.new
+
+      @tokens
+    end
+
+    def eat(str)
+      @code.delete_prefix!(str)
+    end
+
+    def eat_whitespaces
+      @code.sub!(WHITESPACE_RE, '')
+    end
+
+    def expect(str)
+      if @code.start_with?(str)
+        self.eat(str)
+      elsif
+        raise Exception.new("Found character `#{@code[0]}`, expecting `#{str}`")
+      end
+    end
+
+    def scan_top_level_template
+      @tokens << Token::OpenTagStart.new
+      @tokens << Token::OpenTagName.new('template')
+      @tokens << Token::TagEnd.new
+      self.eat('<template')
+      self.eat_whitespaces
+      self.expect('>')
+
+      self.eat_whitespaces
+      root_scanned = false
+      until @code.start_with?('</')
+        if @code.start_with?('<!--')
+          self.scan_comment
+        else
+          unless root_scanned
+            self.scan_tag
+            root_scanned = true
+          end
+        end
+        self.eat_whitespaces
+      end
+
+      self.eat('</')
+      @tokens << Token::ClosingTagStart.new
+      self.expect('template')
+      @tokens << Token::ClosingTagName.new('template')
+      self.eat_whitespaces
+      self.expect('>')
+      @tokens << Token::TagEnd.new
+    end
+
+    def scan_tag
+      tag_name = self.scan_tag_name
+      is_v_pre = false
+      self.eat_whitespaces
+
+      while (@code =~ ATTRIBUTE_NAME_RE) == 0
+        attr = self.scan_attribute
+        if attr[:name] == 'v-pre'
+          is_v_pre = true
+        end
+        self.eat_whitespaces
+      end
+
+      if @code.start_with?('/>')
+        @tokens << Token::SelfClosingTag.new
+        self.eat('/>')
+        return
+      elsif @code.start_with?('>')
+        if VOID_TAG.include?(tag_name)
+          @tokens << Token::SelfClosingTag.new
+          self.eat('>')
+          return
+        else
+          @tokens << Token::TagEnd.new
+          self.eat('>')
+        end
+      end
+
+      until @code.start_with?('</')
+        if @code.start_with?('<!--')
+          self.scan_comment
+        elsif @code.start_with?('<')
+          self.scan_tag
+        elsif @code.start_with?('{{')
+          self.scan_interpolation
+        else
+          self.scan_text(is_v_pre)
+        end
+      end
+
+      self.expect('</')
+      @tokens << Token::ClosingTagStart.new
+      self.expect(tag_name)
+      @tokens << Token::ClosingTagName.new(tag_name)
+      self.eat_whitespaces
+      self.expect('>')
+      @tokens << Token::TagEnd.new
+    end
+
+    def scan_tag_name
+      self.expect('<')
+      @tokens << Token::OpenTagStart.new
+
+      tag_name = @code.slice(TAG_NAME_RE)
+      @tokens << Token::OpenTagName.new(tag_name)
+      self.eat(tag_name)
+      tag_name
+    end
+
+    def scan_attribute
+      name = @code.slice(ATTRIBUTE_NAME_RE)
+      value = nil
+      @tokens << Token::AttributeName.new(name)
+      self.eat(name)
+
+      self.eat_whitespaces
+      return { name: name, value: value } unless @code.start_with?('=')
+
+      self.expect('=')
+      self.eat_whitespaces
+      if (@code =~ ATTRIBUTE_VALUE_RE) == 0
+        self.scan_attribute_value
+        value = self.eat_whitespaces
+      end
+
+      { name: name, value: value }
+    end
+
+    def scan_attribute_value
+      quoted = @code.start_with?("'") || @code.start_with?('"')
+      matched = @code.match(ATTRIBUTE_VALUE_RE)
+      value = matched[1] || matched[2] || matched[3]
+      @tokens << Token::AttributeValue.new(value)
+
+      @code = @code[((quoted ? 2 : 0) + value.size)..-1]
+
+      value
+    end
+
+    def scan_text(ignore_interpolation = false)
+      text = ''
+      until @code.start_with?('<') || (!ignore_interpolation && @code.start_with?('{{'))
+        char = @code[0]
+        self.eat(char)
+        next if char == ' ' && text.end_with?(' ')
+        text << char
+      end
+      @tokens << Token::Text.new(text)
+    end
+
+    def scan_interpolation
+      expr = ''
+      is_string = false
+
+      @tokens << Token::InterpolationStart.new
+      self.eat('{{')
+
+      while is_string || (!is_string && !@code.start_with?('}}'))
+        char = @code[0]
+        expr << char
+        self.eat(char)
+        if char == '"' || char == "'" || char == '`'
+          is_string = !is_string
+        end
+      end
+      expr.strip!
+      @tokens << Token::Interpolation.new(expr)
+
+      @tokens << Token::InterpolationEnd.new
+      self.eat('}}')
+    end
+
+    def scan_comment
+      @tokens << Token::CommentStart.new
+      end_pos = @code.index('-->')
+      if end_pos
+        @tokens << Token::Comment.new(@code[4...end_pos])
+        @tokens << Token::CommentEnd.new
+        @code = @code[end_pos + 3..-1]
+      end
+    end
+
+    def scan_script_block
+      self.eat('<script')
+      self.eat_whitespaces
+
+      lang = if @code.start_with?('lang')
+        self.eat('lang')
+        self.eat_whitespaces
+        self.expect('=')
+        self.eat_whitespaces
+        quoted = @code.start_with?("'") || @code.start_with?('"')
+        matched = @code.match(ATTRIBUTE_VALUE_RE)
+        lang = matched[1] || matched[2] || matched[3]
+        @code = @code[((quoted ? 2 : 0) + lang.size)..-1]
+        self.eat_whitespaces
+        self.expect('>')
+        lang
+      elsif @code.start_with?('>')
+        self.eat('>')
+        nil
+      end
+
+      content = ''
+      is_string = false
+      while is_string || (!is_string && !@code.start_with?('</script'))
+        char = @code[0]
+        if char == '"' || char == "'" || char == '`'
+          is_string = !is_string
+        end
+        content << char
+        self.eat(char)
+      end
+
+      self.eat('</script')
+      self.eat_whitespaces
+      self.expect('>')
+
+      @tokens << Token::ScriptBlock.new(content, lang)
+    end
+
+    def scan_style_block
+      content = ''
+      scoped = false
+      lang = 'css'
+
+      self.eat('<style')
+      self.eat_whitespaces
+
+      until @code.start_with?('>')
+        if @code.start_with?('scoped')
+          scoped = true
+          self.eat('scoped')
+        elsif @code.start_with?('lang')
+          self.eat('lang')
+          self.eat_whitespaces
+          self.expect('=')
+          self.eat_whitespaces
+          quoted = @code.start_with?("'") || @code.start_with?('"')
+          matched = @code.match(ATTRIBUTE_VALUE_RE)
+          lang = matched[1] || matched[2] || matched[3]
+          @code.sub!(QUOTE_RE, '')
+          self.eat(lang)
+          @code.sub!(QUOTE_RE, '')
+        end
+        self.eat_whitespaces
+      end
+
+      self.eat('>')
+
+      until @code.start_with?('</style')
+        char = @code[0]
+        content << char
+        self.eat(char)
+      end
+
+      self.eat('</style')
+      self.eat_whitespaces
+      self.expect('>')
+
+      @tokens << Token::StyleBlock.new(content, lang, scoped)
+    end
+
+    def scan_custom_block
+      self.eat('<')
+      type = @code.slice(TAG_NAME_RE)
+      content = ''
+      self.eat(type)
+
+      self.eat_whitespaces
+      # TODO: support attributes on custom block.
+      self.eat('>')
+
+      until @code.start_with?("</#{type}")
+        char = @code[0]
+        content << char
+        self.eat(char)
+      end
+
+      self.eat("</#{type}")
+      self.eat_whitespaces
+      self.eat('>')
+
+      @tokens << Token::CustomBlock.new(type, content)
+    end
+  end
+end

data/lib/vue_component_compiler/version.rb

@@ -0,0 +1,3 @@
+module VueCompiler
+  VERSION = '0.1.0'
+end

data/vue_component_compiler.gemspec

@@ -0,0 +1,24 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "vue_component_compiler/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = 'vue_component_compiler'
+  spec.version       = VueCompiler::VERSION
+  spec.authors       = ['Pig Fang']
+  spec.email         = ['g-plane@hotmail.com']
+  spec.licenses      = ['MIT']
+  spec.summary       = 'Vue component compiler'
+  spec.homepage      = 'https://github.com/g-plane/vue-component-compiler-rb'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: vue_component_compiler
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Pig Fang
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-11-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 
+email:
+- g-plane@hotmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".editorconfig"
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/vue_component_compiler.rb
+- lib/vue_component_compiler/node.rb
+- lib/vue_component_compiler/parser.rb
+- lib/vue_component_compiler/token.rb
+- lib/vue_component_compiler/tokenizer.rb
+- lib/vue_component_compiler/version.rb
+- vue_component_compiler.gemspec
+homepage: https://github.com/g-plane/vue-component-compiler-rb
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Vue component compiler
+test_files: []