metannotation 1.0.0rc2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 81838b946fe1e165ee0c043ed9edba428a670c70ca276b315a763ad1a7aa7098
+  data.tar.gz: 9a384326cc440bf79253b94190f12b10522300a823e0d087597bf4b9fd571b05
+SHA512:
+  metadata.gz: 10c98a986bd6486ab96e03d6f5349d47baad383f9cf8c2a4b663d6289e894e9017de7ed7fb7c75cec1de2ce7bfd88d94e227d24f373d9e161a4836c93add09fa
+  data.tar.gz: 6c7611d19cc6212fb186b6d0b04072113030317739a41865865647a64159c27a081ecf199cb8d1912671d65cfab7598f4620b9f719e61e76bf008b07b1eb614b

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}"}
+
+# Specify your gem's dependencies in metannotation.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +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.

data/README.md

@@ -0,0 +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).

data/Rakefile

@@ -0,0 +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

data/lib/metannotation/core.rb

@@ -0,0 +1,50 @@
+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
+

data/lib/metannotation/core_ext/module.rb

@@ -0,0 +1,30 @@
+require 'metannotation/core_ext/string'
+
+class Module # :nodoc:
+  using Metannotation::StringExt # :nodoc:
+
+  # +label+ an annotation
+  #   class MyClass
+  #       label Annotation, param1, param2
+  #   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
+  end
+
+  # +labels+ annotations
+  # use [] if having parameters
+  #   class MyClass
+  #       labels 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
+  end
+end

data/lib/metannotation/core_ext/string.rb

@@ -0,0 +1,196 @@
+module Metannotation # :nodoc:
+  # Some String tools from active support
+  module StringExt
+    refine ::String do
+      # Removes the module part from the expression in the string.
+      #
+      #   demodulize('ActiveRecord::CoreExtensions::String::Inflections') # => "Inflections"
+      #   demodulize('Inflections')                                       # => "Inflections"
+      #   demodulize('::Inflections')                                     # => "Inflections"
+      #   demodulize('')                                                  # => ""
+      #
+      # See active_support gem
+      def demodulize
+        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

@@ -0,0 +1,44 @@
+require 'metannotation/core'
+
+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
+      end
+
+      private
+
+      # Define core features
+      def annotation_define(annotation)
+        Core.define(annotation)
+        annotation
+      end
+
+      # Define +to+ method that will be execute when annotate target
+      def annotation_to_do(annotation)
+        annotation.define_singleton_method(:to) do |&block|
+          # The +do+ block is saved as +@annotated_do+ val.
+          annotation.singleton_class.send(:attr_accessor, :annotated_do)
+          annotation.annotated_do = block
+        end
+        annotation
+      end
+
+      # Define what to do when annotation includes another annotation
+      # module AA
+      #   include BB # a class annotation
+      #   include CC # a method annotation
+      # end
+      # AA is a class annotation
+      def annotation_included(annotation)
+        annotation.define_singleton_method(:included) do |sub_annotation|
+          sub_annotation.include annotation.annotation_type unless sub_annotation.respond_to? :annotation_type
+        end
+        annotation
+      end
+    end
+  end
+end

data/lib/metannotation/version.rb

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

data/lib/metannotation.rb

@@ -0,0 +1,60 @@
+require 'metannotation/version'
+require 'metannotation/core_ext/module'
+require 'metannotation/define'
+
+# Define method-annotation
+#
+#   module MyAnnotation
+#     include Metannotation::Method
+#   end
+#
+# Use method-annotation
+#
+#   class MyClass
+#     label MyAnnotation
+#     my_annotation def my_method;end
+#   end
+#
+# Define and use class-annotation
+#
+#   module YourAnnotation
+#     include Metannotation::Class
+#   end
+#
+#   class YourClass
+#     label YourAnnotation
+#   end
+#
+module Metannotation
+  # method-annotation
+  module Method
+    def self.included(annotation) # :nodoc:
+      Metannotation.define_annotation(annotation, self)
+    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:
+
+    # 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
+    end
+  end
+end

data/metannotation.gemspec

@@ -0,0 +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

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: metannotation
+version: !ruby/object:Gem::Version
+  version: 1.0.0rc2
+platform: ruby
+authors:
+- Hdzi
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-06-14 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: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: This Gem provides "annotation" for Ruby.
+email:
+- taojinhou@qq.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- 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
+- lib/metannotation/version.rb
+- metannotation.gemspec
+homepage: https://github.com/Hdzi/metannotation
+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: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Ruby Annotation
+test_files: []