metannotation 1.0.0rc2 → 2.0.0Beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81838b946fe1e165ee0c043ed9edba428a670c70ca276b315a763ad1a7aa7098
-  data.tar.gz: 9a384326cc440bf79253b94190f12b10522300a823e0d087597bf4b9fd571b05
+  metadata.gz: 241fb3a4968fc2e7f0214bde05f3d89f6da5f7601e3ae0a0afe21493420c1b2a
+  data.tar.gz: d69d4a83d51176fd7f95539f5709fb708db1ebcbcd4c941a098f47308dfe1daf
 SHA512:
-  metadata.gz: 10c98a986bd6486ab96e03d6f5349d47baad383f9cf8c2a4b663d6289e894e9017de7ed7fb7c75cec1de2ce7bfd88d94e227d24f373d9e161a4836c93add09fa
-  data.tar.gz: 6c7611d19cc6212fb186b6d0b04072113030317739a41865865647a64159c27a081ecf199cb8d1912671d65cfab7598f4620b9f719e61e76bf008b07b1eb614b
+  metadata.gz: '09aad7bdf0d99dae987ddcab9b211a24b59f8693ead4fa2b4fe4009bfbf056b443625f08987dccc9ec55133bd883306c101068808c6fcc291f2c8742bb097a56'
+  data.tar.gz: 70ef5ad2966133246a4144d712f09c8269a77b47725dddede4527a83c0950b95d6500ba176c968ecf9a98defb2a24ccba3042d9eadc23dc2beec0c59f4a01490

data/.gitignore

@@ -1,11 +1,11 @@
-/.bundle/
-/.yardoc
-/_yardoc/
-/coverage/
-/doc/
-/pkg/
-/spec/reports/
-/tmp/
-/Gemfile.lock
-/.idea
-/metannotation.iml
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/Gemfile.lock
+/.idea
+/metannotation.iml

data/Gemfile

@@ -1,4 +1,4 @@
-source "https://rubygems.org"
+source "https://gems.ruby-china.com"
 
 git_source(:github) {|repo_name| "https://github.com/#{repo_name}"}
 

data/LICENSE.txt

@@ -1,21 +1,21 @@
-The MIT License (MIT)
-
-Copyright (c) 2018 Hdzi
-
-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.
+The MIT License (MIT)
+
+Copyright (c) 2018 Hdzi
+
+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

@@ -1,43 +1,43 @@
-# Metannotation
-
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/metannotation`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'metannotation'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install metannotation
-
-## Usage
-
-TODO: Write usage instructions here
-
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/metannotation. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
-
-## License
-
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
-
-## Code of Conduct
-
-Everyone interacting in the Metannotation project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/metannotation/blob/master/CODE_OF_CONDUCT.md).
+# Metannotation
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/metannotation`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'metannotation'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install metannotation
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/metannotation. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Metannotation project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/metannotation/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -1,10 +1,10 @@
-require "bundler/gem_tasks"
-require "rake/testtask"
-
-Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  t.libs << "lib"
-  t.test_files = FileList["test/**/*_test.rb"]
-end
-
-task :default => :test
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/lib/metannotation.rb

@@ -12,7 +12,7 @@ require 'metannotation/define'
 #
 #   class MyClass
 #     label MyAnnotation
-#     my_annotation def my_method;end
+#     atMyAnnotation def my_method;end
 #   end
 #
 # Define and use class-annotation
@@ -22,39 +22,37 @@ require 'metannotation/define'
 #   end
 #
 #   class YourClass
-#     label YourAnnotation
+#     label_self YourAnnotation
 #   end
 #
 module Metannotation
+  def included(annotation)
+    Define.define_annotation(annotation, self)
+  end
+
+  def check(&block)
+    instance_variable_set :@__annotation_check, block
+  end
+
   # method-annotation
   module Method
-    def self.included(annotation) # :nodoc:
-      Metannotation.define_annotation(annotation, self)
+    extend Metannotation
+
+    check do |fun_sym|
+      # check it a method
+      raise "Annotation's last parameter must be a method symbol!" unless public_method_defined?(fun_sym) ||
+          protected_method_defined?(fun_sym) ||
+          private_method_defined?(fun_sym)
     end
   end
 
   # class-annotation
   module Class
-    def self.included(annotation) # :nodoc:
-      Metannotation.define_annotation(annotation, self)
-    end
-  end
-
-  class << self
-    # Define annotation
-    def define_annotation(annotation, type)
-      Define.do check_annotation(annotation, type)
-    end
-
-    private
-
-    using StringExt # :nodoc:
+    extend Metannotation
 
-    # Define some variables and methods that provide annotation information in the module
-    def check_annotation(annotation, type)
-      annotation.define_singleton_method(:annotation_type) {type}
-      annotation.define_singleton_method(:annotation_name) {simple_name}
-      annotation
+    check do |cls|
+      # check it a class
+      raise "Annotation's last parameter must be a class constant!" unless cls.class.is_a? Module
     end
   end
 end

data/lib/metannotation/core_ext/module.rb

@@ -1,30 +1,22 @@
 require 'metannotation/core_ext/string'
 
 class Module # :nodoc:
-  using Metannotation::StringExt # :nodoc:
-
   # +label+ an annotation
   #   class MyClass
-  #       label Annotation, param1, param2
+  #       label Annotation1, Annotation2
   #   end
-  def label(annotation, *parm)
-    unless singleton_class.include? annotation
-      extend annotation
-      send(annotation.simple_name, *parm, self) if annotation.annotation_type == Metannotation::Class
-    end
+  def label(*annotations)
+    annotations.each {|annotation| extend annotation}
   end
 
-  # +labels+ annotations
-  # use [] if having parameters
+  # +label_self+ annotations
   #   class MyClass
-  #       labels Annotation1, [Annotation2, param]
+  #       label_self Annotation1, [Annotation2, param]
   #   end
-  def labels(*annotations)
-    annotations.each {|annotation| label *annotation}
-  end
-
-  # get module's simple name
-  def simple_name
-    @__simple_name ||= to_s.demodulize.underscore.to_sym
+  def label_self(*annotations)
+    annotations.each do |annotation, *parm|
+      extend annotation
+      send(annotation.annotation_name, *parm, self)
+    end
   end
 end

data/lib/metannotation/core_ext/string.rb

@@ -11,186 +11,12 @@ module Metannotation # :nodoc:
       #
       # See active_support gem
       def demodulize
-        if i = self.rindex('::')
+        if (i = self.rindex('::'))
           self[(i + 2)..-1]
         else
           self
         end
       end
-
-      # Makes an underscored, lowercase form from the expression in the string.
-      # Changes '::' to '/' to convert namespaces to paths.
-      #
-      #   underscore('ActiveModel')         # => "active_model"
-      #   underscore('ActiveModel::Errors') # => "active_model/errors"
-      #
-      # See active_support gem
-      def underscore
-        return self unless self =~ /[A-Z-]|::/
-        word = self.gsub('::'.freeze, '/'.freeze)
-        word.gsub!(/(?:(?<=([A-Za-z\d]))|\b)((?-mix:(?=a)b))(?=\b|[^a-z])/) {"#{$1 && '_'.freeze }#{$2.downcase}"}
-        word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2'.freeze)
-        word.gsub!(/([a-z\d])([A-Z])/, '\1_\2'.freeze)
-        word.tr!("-".freeze, "_".freeze)
-        word.downcase!
-        word
-      end
-
-
-      # Converts strings to UpperCamelCase.
-      # If the +uppercase_first_letter+ parameter is set to false, then produces
-      # lowerCamelCase.
-      #
-      # Also converts '/' to '::' which is useful for converting
-      # paths to namespaces.
-      #
-      #   camelize('active_model')                # => "ActiveModel"
-      #   camelize('active_model', false)         # => "activeModel"
-      #   camelize('active_model/errors')         # => "ActiveModel::Errors"
-      #   camelize('active_model/errors', false)  # => "activeModel::Errors"
-      #
-      # As a rule of thumb you can think of +camelize+ as the inverse of
-      # #underscore, though there are cases where that does not hold:
-      #
-      #   camelize(underscore('SSLError'))        # => "SslError"
-      #
-      # See active_support gem
-      def camelize(uppercase_first_letter = true)
-        if uppercase_first_letter
-          string = self.sub(/^[a-z\d]*/) {|match| match.capitalize}
-        else
-          string = self.sub(/^(?:(?-mix:(?=a)b)(?=\b|[A-Z_])|\w)/) {|match| match.downcase}
-        end
-        string.gsub!(/(?:_|(\/))([a-z\d]*)/i) {"#{$1}#{$2.capitalize}"}
-        string.gsub!('/'.freeze, '::'.freeze)
-        string
-      end
-
-      # Returns the plural form of the word in the string.
-      #
-      # If passed an optional +locale+ parameter, the word will be
-      # pluralized using rules defined for that language. By default,
-      # this parameter is set to <tt>:en</tt>.
-      #
-      #   pluralize('post')             # => "posts"
-      #   pluralize('octopus')          # => "octopi"
-      #   pluralize('sheep')            # => "sheep"
-      #   pluralize('words')            # => "words"
-      #   pluralize('CamelOctopus')     # => "CamelOctopi"
-      #
-      # See active_support gem
-      def pluralize
-        rules = [[/(z)ombies$/i, "\\1ombies"],
-                 [/(z)ombie$/i, "\\1ombies"],
-                 [/(m)oves$/i, "\\1oves"],
-                 [/(m)ove$/i, "\\1oves"],
-                 [/(s)exes$/i, "\\1exes"],
-                 [/(s)ex$/i, "\\1exes"],
-                 [/(c)hildren$/i, "\\1hildren"],
-                 [/(c)hild$/i, "\\1hildren"],
-                 [/(m)en$/i, "\\1en"],
-                 [/(m)an$/i, "\\1en"],
-                 [/(p)eople$/i, "\\1eople"],
-                 [/(p)erson$/i, "\\1eople"],
-                 [/(quiz)$/i, "\\1zes"],
-                 [/^(oxen)$/i, "\\1"],
-                 [/^(ox)$/i, "\\1en"],
-                 [/^(m|l)ice$/i, "\\1ice"],
-                 [/^(m|l)ouse$/i, "\\1ice"],
-                 [/(matr|vert|ind)(?:ix|ex)$/i, "\\1ices"],
-                 [/(x|ch|ss|sh)$/i, "\\1es"],
-                 [/([^aeiouy]|qu)y$/i, "\\1ies"],
-                 [/(hive)$/i, "\\1s"],
-                 [/(?:([^f])fe|([lr])f)$/i, "\\1\\2ves"],
-                 [/sis$/i, "ses"], [/([ti])a$/i, "\\1a"],
-                 [/([ti])um$/i, "\\1a"],
-                 [/(buffal|tomat)o$/i, "\\1oes"],
-                 [/(bu)s$/i, "\\1ses"],
-                 [/(alias|status)$/i, "\\1es"],
-                 [/(octop|vir)i$/i, "\\1i"],
-                 [/(octop|vir)us$/i, "\\1i"],
-                 [/^(ax|test)is$/i, "\\1es"],
-                 [/s$/i, "s"], [/$/, "s"]]
-        apply_inflections(self, rules)
-      end
-
-      # The reverse of #pluralize, returns the singular form of a word in a
-      # string.
-      #
-      # If passed an optional +locale+ parameter, the word will be
-      # singularized using rules defined for that language. By default,
-      # this parameter is set to <tt>:en</tt>.
-      #
-      #   singularize('posts')            # => "post"
-      #   singularize('octopi')           # => "octopus"
-      #   singularize('sheep')            # => "sheep"
-      #   singularize('word')             # => "word"
-      #   singularize('CamelOctopi')      # => "CamelOctopus"
-      #   singularize('leyes', :es)       # => "ley"
-      #
-      # See active_support gem
-      def singularize
-        rules = [[/(z)ombies$/i, "\\1ombie"],
-                 [/(z)ombie$/i, "\\1ombie"],
-                 [/(m)oves$/i, "\\1ove"],
-                 [/(m)ove$/i, "\\1ove"],
-                 [/(s)exes$/i, "\\1ex"],
-                 [/(s)ex$/i, "\\1ex"],
-                 [/(c)hildren$/i, "\\1hild"],
-                 [/(c)hild$/i, "\\1hild"],
-                 [/(m)en$/i, "\\1an"],
-                 [/(m)an$/i, "\\1an"],
-                 [/(p)eople$/i, "\\1erson"],
-                 [/(p)erson$/i, "\\1erson"],
-                 [/(database)s$/i, "\\1"],
-                 [/(quiz)zes$/i, "\\1"],
-                 [/(matr)ices$/i, "\\1ix"],
-                 [/(vert|ind)ices$/i, "\\1ex"],
-                 [/^(ox)en/i, "\\1"],
-                 [/(alias|status)(es)?$/i, "\\1"],
-                 [/(octop|vir)(us|i)$/i, "\\1us"],
-                 [/^(a)x[ie]s$/i, "\\1xis"],
-                 [/(cris|test)(is|es)$/i, "\\1is"],
-                 [/(shoe)s$/i, "\\1"],
-                 [/(o)es$/i, "\\1"],
-                 [/(bus)(es)?$/i, "\\1"],
-                 [/^(m|l)ice$/i, "\\1ouse"],
-                 [/(x|ch|ss|sh)es$/i, "\\1"],
-                 [/(m)ovies$/i, "\\1ovie"],
-                 [/(s)eries$/i, "\\1eries"],
-                 [/([^aeiouy]|qu)ies$/i, "\\1y"],
-                 [/([lr])ves$/i, "\\1f"],
-                 [/(tive)s$/i, "\\1"],
-                 [/(hive)s$/i, "\\1"],
-                 [/([^f])ves$/i, "\\1fe"],
-                 [/(^analy)(sis|ses)$/i, "\\1sis"],
-                 [/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)(sis|ses)$/i, "\\1sis"],
-                 [/([ti])a$/i, "\\1um"],
-                 [/(n)ews$/i, "\\1ews"],
-                 [/(ss)$/i, "\\1"],
-                 [/s$/i, ""]]
-
-        apply_inflections(self, rules)
-      end
-
-      private
-
-      # Applies inflection rules for +singularize+ and +pluralize+.
-      #
-      #  apply_inflections('post', inflections.plurals)    # => "posts"
-      #  apply_inflections('posts', inflections.singulars) # => "post"
-      #
-      # See active_support gem
-      def apply_inflections(word, rules)
-        result = word.dup
-
-        if word.empty?
-          result
-        else
-          rules.each {|(rule, replacement)| break if result.sub!(rule, replacement)}
-          result
-        end
-      end
     end
   end
 end

data/lib/metannotation/define.rb

@@ -1,20 +1,34 @@
-require 'metannotation/core'
+require 'metannotation/core_ext/string'
 
 module Metannotation # :nodoc:
   # Define annotation
   module Define
     class << self
       # An interface to define an annotation
-      def do(annotation)
-        annotation_included annotation_to_do annotation_define annotation
+      def define_annotation(annotation, type)
+        annotation_reflect annotation, type
+        annotation_define annotation, type
+        annotation_to_do annotation
+        annotation_included annotation
       end
 
       private
 
       # Define core features
-      def annotation_define(annotation)
-        Core.define(annotation)
-        annotation
+      def annotation_define(annotation, type)
+        annotation.send :define_method, annotation.annotation_name do |*args, target|
+          # check target a method or a class or a other
+          instance_exec(target, &type.instance_variable_get(:@__annotation_check))
+          # execute annotation's +to_do_block+
+          # An annotation can include another annotations, all same type included annotations's +to_do_block+
+          # will be execute.
+          annotation.included_modules.unshift(annotation).each do |super_annotation|
+            class_exec(target, annotation, *args, &super_annotation.annotated_do) if super_annotation.singleton_class.method_defined?(:annotated_do) and
+                super_annotation.annotation_type == annotation.annotation_type
+          end
+          # an1 an2 target
+          target
+        end
       end
 
       # Define +to+ method that will be execute when annotate target
@@ -24,7 +38,6 @@ module Metannotation # :nodoc:
           annotation.singleton_class.send(:attr_accessor, :annotated_do)
           annotation.annotated_do = block
         end
-        annotation
       end
 
       # Define what to do when annotation includes another annotation
@@ -37,7 +50,13 @@ module Metannotation # :nodoc:
         annotation.define_singleton_method(:included) do |sub_annotation|
           sub_annotation.include annotation.annotation_type unless sub_annotation.respond_to? :annotation_type
         end
-        annotation
+      end
+
+      using StringExt
+      # Define some variables and methods that provide annotation information in the module
+      def annotation_reflect(annotation, type)
+        annotation.define_singleton_method(:annotation_type) {type}
+        annotation.define_singleton_method(:annotation_name) {"at#{to_s.demodulize}"}
       end
     end
   end

data/lib/metannotation/version.rb

@@ -1,3 +1,3 @@
-module Metannotation
-  VERSION = "1.0.0rc2"
-end
+module Metannotation
+  VERSION = "2.0.0Beta2"
+end

data/metannotation.gemspec

@@ -1,37 +1,37 @@
-lib = File.expand_path("../lib", __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "metannotation/version"
-
-Gem::Specification.new do |spec|
-  spec.name = "metannotation"
-  spec.version = Metannotation::VERSION
-  spec.authors = ["Hdzi"]
-  spec.email = ["taojinhou@qq.com"]
-
-  spec.summary = %q{Ruby Annotation}
-  spec.description = %q{This Gem provides "annotation" for Ruby.}
-  spec.homepage = "https://github.com/Hdzi/metannotation"
-  spec.license = "MIT"
-
-  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
-  # to allow pushing to a single host or delete this section to allow pushing to any host.
-  # if spec.respond_to?(:metadata)
-  #   spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
-  # else
-  #   raise "RubyGems 2.0 or newer is required to protect against " \
-  #     "public gem pushes."
-  # end
-
-  # 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.bindir = "exe"
-  spec.executables = spec.files.grep(%r{^exe/}) {|f| File.basename(f)}
-  spec.require_paths = ["lib"]
-
-  spec.add_development_dependency "bundler", "~> 1.16"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "minitest", "~> 5.0"
-end
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "metannotation/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "metannotation"
+  spec.version = Metannotation::VERSION
+  spec.authors = ["Hdzi"]
+  spec.email = ["taojinhou@qq.com"]
+
+  spec.summary = %q{Ruby Annotation}
+  spec.description = %q{This Gem provides "annotation" for Ruby.}
+  spec.homepage = "https://github.com/Hdzi/metannotation"
+  spec.license = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+  # else
+  #   raise "RubyGems 2.0 or newer is required to protect against " \
+  #     "public gem pushes."
+  # end
+
+  # 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.bindir = "exe"
+  spec.executables = spec.files.grep(%r{^exe/}) {|f| File.basename(f)}
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: metannotation
 version: !ruby/object:Gem::Version
-  version: 1.0.0rc2
+  version: 2.0.0Beta2
 platform: ruby
 authors:
 - Hdzi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-06-14 00:00:00.000000000 Z
+date: 2018-08-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -65,7 +65,6 @@ files:
 - README.md
 - Rakefile
 - lib/metannotation.rb
-- lib/metannotation/core.rb
 - lib/metannotation/core_ext/module.rb
 - lib/metannotation/core_ext/string.rb
 - lib/metannotation/define.rb

data/lib/metannotation/core.rb

@@ -1,50 +0,0 @@
-module Metannotation # :nodoc:
-  # It's core of annotation
-  module Core
-    class << self
-      # Define annotation's core features depend it's type
-      def define(annotation)
-        annotation.send(:define_method, annotation.simple_name, &send("def_#{annotation.annotation_type.simple_name}_annotation", annotation))
-      end
-
-      private
-
-      # Define the method-annotation
-      def def_method_annotation(annotation)
-        def_annotation_common(annotation) do |fun_sym|
-          # check it a method
-          raise "Annotation's last parameter must be a method symbol!" unless public_method_defined?(fun_sym) ||
-              protected_method_defined?(fun_sym) ||
-              private_method_defined?(fun_sym)
-        end
-      end
-
-      # Define the class-annotation
-      def def_class_annotation(annotation)
-        def_annotation_common(annotation) do |cls|
-          # check it a class
-          raise "Annotation's last parameter must be a class constant!" unless cls.class.is_a? Module
-        end
-      end
-
-      # Define what to do when annotation a target
-      def def_annotation_common(annotation, &block)
-        # What target to do
-        proc do |*args, target|
-          # check target a method or a class or a other
-          instance_exec(target, &block)
-          # execute annotation's +to_do_block+
-          # An annotation can include another annotations, all same type included annotations's +to_do_block+
-          # will be execute.
-          annotation.included_modules.unshift(annotation).each do |super_annotation|
-            class_exec(target, annotation, *args, &super_annotation.annotated_do) if super_annotation.singleton_class.method_defined?(:annotated_do) and
-                super_annotation.annotation_type == annotation.annotation_type
-          end
-          # an1 an2 target
-          target
-        end
-      end
-    end
-  end
-end
-