validacity 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 37e0d8cfd4674671362980b8431da1c4ed1714e9c9217ec6453c7eb0179db44c
-  data.tar.gz: 6382080b9a6bcc1ec95c31539ba5e597fc7b9029e185aaae5527e31a1d2ef70f
+  metadata.gz: ff1728df7b05d4d9882b039884cba8985df95824810d8f64f2a363d6f109655a
+  data.tar.gz: 1b2071f2cf21c10aeda419eb264e456942550a50fe79acb9fdaabbd7b3110304
 SHA512:
-  metadata.gz: b3e8278b9b416944cffef47ae862b447d92d1ec9ec405f0f684cf0c95cfca8143b1864093ce06c38e9f6f9f52ce96e032ff8a34fd762a29173515d808881762e
-  data.tar.gz: 1c4d95d4ff6742ae90992d840e9e5b0b2561b8718f60068c8a453b544e0550ca83cb8f1c75af8e7e2be6ed7150539ef7217dd5be3becf34aaf241d554a854c6b
+  metadata.gz: 15d81cf9ad56fd8255984d73e98a1e825bd380f70b002324f22c7e292b098ee6ec01266b95cae5c90906418fc27f7c4f74974a680cbdb9780cc9a1cb4401b69c
+  data.tar.gz: 9ac2b3080c9c2cd2cc34ad483b58961050d4bf63fca2c33020bc9bdbb185e8499959207fc202463dcd7c8a0bdcf458510d210e8b2fdc154f2ba5900f97aff302

data/README.md

@@ -1,8 +1,49 @@
 # Validacity
-Short description and motivation.
+
+Move your validation logic out of your models or form objects.
 
 ## Usage
-How to use my plugin.
+
+You can append validators on-fly and then remove some of them if not needed.
+
+It can be very suitable if you need to validate different states of the same object differently. Say you're using a state machine and each state have it's own field set and the fields from other satates shouldn't be validated at this time.
+
+Or perhaps you just have to many constructions like `validate :blablabla, presence: true` in your model and you want to get rid of it.
+
+All you need is to add a concern to your model:
+
+```ruby
+
+# app/models/user.rb
+
+class User
+  include Validacity::Validatable
+  validations :user_personal_data
+end
+
+```
+
+And generate a validator:
+
+```ruby
+
+# app/validators/user_personal_data_validator.rb
+
+class UserPersonalDataValidator
+  validate :name, presence_of: true
+  # ...a ton of different validators
+end
+
+```
+
+Now call validator with the regular methods like:
+
+
+```ruby
+
+user.valid?
+
+```
 
 ## Installation
 Add this line to your application's Gemfile:
@@ -16,9 +57,14 @@ And then execute:
 $ bundle
 ```
 
-Or install it yourself as:
+Now run the validator installation command:
+```bash
+$ bundle exec rails g validacity:install
+```
+
+And the event validator:
 ```bash
-$ gem install validacity
+$ bundle exec rails g validacity:validator Event
 ```
 
 ## Contributing

data/lib/generators/validacity/install_generator.rb

@@ -1,21 +1,453 @@
+begin
+  require "thor/group"
+rescue LoadError
+  puts "Thor is not available.\nIf you ran this command from a git checkout " \
+       "of Rails, please make sure thor is installed,\nand run this command " \
+       "as `ruby #{$0} #{(ARGV | ['--dev']).join(" ")}`"
+  exit
+end
+
 module Validacity
   module Generators
-    class ValidacityGenerator < Rails::Generators::NamedBase
+    class InstallGenerator < ::Rails::Generators::Base
       source_root File.expand_path("templates", __dir__)
 
       def create_initializer_file
-        content = <<-'RUBY'
+        content = <<-'RUBY'.gsub(/^\ {10}/, "")
+          require_dependency "validacity"
+
           Validacity.configure do |config|
-            config.search_paths "#{namespaced_path}/app/validators/**/*_validator.rb"
+            config.search_paths "#{__dir__}/../app/validators/**/*_validator.rb"
           end
         RUBY
-        create_file "#{namespaced_path}/config/initializers/validacity_initializer.rb",
-                    content
+        create_file "config/initializers/validacity_initializer.rb", content
       end
 
       def copy_application_policy
-        template "application_validator.rb",
-                 "app/validators/application_validator.rb"
+        validator_file = File.join("app/validators", class_path,
+                                   "application_validator.rb")
+        template "application_validator.rb", validator_file
+      end
+
+      include Thor::Actions
+      include Rails::Generators::Actions
+
+      class_option :skip_namespace, type: :boolean, default: false,
+                                    desc: "Skip namespace (affects only isolated applications)"
+
+      add_runtime_options!
+      strict_args_position!
+
+      # Returns the source root for this generator using default_source_root as default.
+      def self.source_root(path = nil)
+        @_source_root = path if path
+        @_source_root ||= default_source_root
+      end
+
+      # Tries to get the description from a USAGE file one folder above the source
+      # root otherwise uses a default description.
+      def self.desc(description = nil)
+        return super if description
+
+        @desc ||= if usage_path
+          ERB.new(File.read(usage_path)).result(binding)
+        else
+          "Description:\n    Create #{base_name.humanize.downcase} files for #{generator_name} generator."
+        end
+      end
+
+      # Convenience method to get the namespace from the class name. It's the
+      # same as Thor default except that the Generator at the end of the class
+      # is removed.
+      def self.namespace(name = nil)
+        return super if name
+        @namespace ||= super.sub(/_generator$/, "").sub(/:generators:/, ":")
+      end
+
+      # Convenience method to hide this generator from the available ones when
+      # running rails generator command.
+      def self.hide!
+        Rails::Generators.hide_namespace(namespace)
+      end
+
+      # Invoke a generator based on the value supplied by the user to the
+      # given option named "name". A class option is created when this method
+      # is invoked and you can set a hash to customize it.
+      #
+      # ==== Examples
+      #
+      #   module Rails::Generators
+      #     class ControllerGenerator < Base
+      #       hook_for :test_framework, aliases: "-t"
+      #     end
+      #   end
+      #
+      # The example above will create a test framework option and will invoke
+      # a generator based on the user supplied value.
+      #
+      # For example, if the user invoke the controller generator as:
+      #
+      #   rails generate controller Account --test-framework=test_unit
+      #
+      # The controller generator will then try to invoke the following generators:
+      #
+      #   "rails:test_unit", "test_unit:controller", "test_unit"
+      #
+      # Notice that "rails:generators:test_unit" could be loaded as well, what
+      # Rails looks for is the first and last parts of the namespace. This is what
+      # allows any test framework to hook into Rails as long as it provides any
+      # of the hooks above.
+      #
+      # ==== Options
+      #
+      # The first and last part used to find the generator to be invoked are
+      # guessed based on class invokes hook_for, as noticed in the example above.
+      # This can be customized with two options: :in and :as.
+      #
+      # Let's suppose you are creating a generator that needs to invoke the
+      # controller generator from test unit. Your first attempt is:
+      #
+      #   class AwesomeGenerator < Rails::Generators::Base
+      #     hook_for :test_framework
+      #   end
+      #
+      # The lookup in this case for test_unit as input is:
+      #
+      #   "test_unit:awesome", "test_unit"
+      #
+      # Which is not the desired lookup. You can change it by providing the
+      # :as option:
+      #
+      #   class AwesomeGenerator < Rails::Generators::Base
+      #     hook_for :test_framework, as: :controller
+      #   end
+      #
+      # And now it will look up at:
+      #
+      #   "test_unit:controller", "test_unit"
+      #
+      # Similarly, if you want it to also look up in the rails namespace, you
+      # just need to provide the :in value:
+      #
+      #   class AwesomeGenerator < Rails::Generators::Base
+      #     hook_for :test_framework, in: :rails, as: :controller
+      #   end
+      #
+      # And the lookup is exactly the same as previously:
+      #
+      #   "rails:test_unit", "test_unit:controller", "test_unit"
+      #
+      # ==== Switches
+      #
+      # All hooks come with switches for user interface. If you do not want
+      # to use any test framework, you can do:
+      #
+      #   rails generate controller Account --skip-test-framework
+      #
+      # Or similarly:
+      #
+      #   rails generate controller Account --no-test-framework
+      #
+      # ==== Boolean hooks
+      #
+      # In some cases, you may want to provide a boolean hook. For example, webrat
+      # developers might want to have webrat available on controller generator.
+      # This can be achieved as:
+      #
+      #   Rails::Generators::ControllerGenerator.hook_for :webrat, type: :boolean
+      #
+      # Then, if you want webrat to be invoked, just supply:
+      #
+      #   rails generate controller Account --webrat
+      #
+      # The hooks lookup is similar as above:
+      #
+      #   "rails:generators:webrat", "webrat:generators:controller", "webrat"
+      #
+      # ==== Custom invocations
+      #
+      # You can also supply a block to hook_for to customize how the hook is
+      # going to be invoked. The block receives two arguments, an instance
+      # of the current class and the class to be invoked.
+      #
+      # For example, in the resource generator, the controller should be invoked
+      # with a pluralized class name. But by default it is invoked with the same
+      # name as the resource generator, which is singular. To change this, we
+      # can give a block to customize how the controller can be invoked.
+      #
+      #   hook_for :resource_controller do |instance, controller|
+      #     instance.invoke controller, [ instance.name.pluralize ]
+      #   end
+      #
+      def self.hook_for(*names, &block)
+        options = names.extract_options!
+        in_base = options.delete(:in) || base_name
+        as_hook = options.delete(:as) || generator_name
+
+        names.each do |name|
+          unless class_options.key?(name)
+            defaults = if options[:type] == :boolean
+              {}
+            elsif [true, false].include?(default_value_for_option(name, options))
+              { banner: "" }
+            else
+              { desc: "#{name.to_s.humanize} to be invoked", banner: "NAME" }
+            end
+
+            class_option(name, defaults.merge!(options))
+          end
+
+          hooks[name] = [ in_base, as_hook ]
+          invoke_from_option(name, options, &block)
+        end
+      end
+
+      # Remove a previously added hook.
+      #
+      #   remove_hook_for :orm
+      def self.remove_hook_for(*names)
+        remove_invocation(*names)
+
+        names.each do |name|
+          hooks.delete(name)
+        end
+      end
+
+      # Make class option aware of Rails::Generators.options and Rails::Generators.aliases.
+      def self.class_option(name, options = {}) #:nodoc:
+        options[:desc]    = "Indicates when to generate #{name.to_s.humanize.downcase}" unless options.key?(:desc)
+        options[:aliases] = default_aliases_for_option(name, options)
+        options[:default] = default_value_for_option(name, options)
+        super(name, options)
+      end
+
+      # Returns the default source root for a given generator. This is used internally
+      # by rails to set its generators source root. If you want to customize your source
+      # root, you should use source_root.
+      def self.default_source_root
+        return unless base_name && generator_name
+        return unless default_generator_root
+        path = File.join(default_generator_root, "templates")
+        path if File.exist?(path)
+      end
+
+      # Returns the base root for a common set of generators. This is used to dynamically
+      # guess the default source root.
+      def self.base_root
+        __dir__
+      end
+
+      # Cache source root and add lib/generators/base/generator/templates to
+      # source paths.
+      def self.inherited(base) #:nodoc:
+        super
+
+        # Invoke source_root so the default_source_root is set.
+        base.source_root
+
+        if base.name && base.name !~ /Base$/
+          Rails::Generators.subclasses << base
+
+          Rails::Generators.templates_path.each do |path|
+            if base.name.include?("::")
+              base.source_paths << File.join(path, base.base_name, base.generator_name)
+            else
+              base.source_paths << File.join(path, base.generator_name)
+            end
+          end
+        end
+      end
+
+      private
+
+      # Check whether the given class names are already taken by user
+      # application or Ruby on Rails.
+      def class_collisions(*class_names)
+        return unless behavior == :invoke
+
+        class_names.flatten.each do |class_name|
+          class_name = class_name.to_s
+          next if class_name.strip.empty?
+
+          # Split the class from its module nesting
+          nesting = class_name.split("::")
+          last_name = nesting.pop
+          last = extract_last_module(nesting)
+
+          if last && last.const_defined?(last_name.camelize, false)
+            raise Error, "The name '#{class_name}' is either already used in your application " \
+                         "or reserved by Ruby on Rails. Please choose an alternative and run "  \
+                         "this generator again."
+          end
+        end
+      end
+
+      # Takes in an array of nested modules and extracts the last module
+      def extract_last_module(nesting) # :doc:
+        nesting.inject(Object) do |last_module, nest|
+          break unless last_module.const_defined?(nest, false)
+          last_module.const_get(nest)
+        end
+      end
+
+      # Wrap block with namespace of current application
+      # if namespace exists and is not skipped
+      def module_namespacing(&block) # :doc:
+        content = capture(&block)
+        content = wrap_with_namespace(content) if namespaced?
+        concat(content)
+      end
+
+      def indent(content, multiplier = 2) # :doc:
+        spaces = " " * multiplier
+        content.each_line.map { |line| line.blank? ? line : "#{spaces}#{line}" }.join
+      end
+
+      def wrap_with_namespace(content) # :doc:
+        content = indent(content).chomp
+        "module #{namespace.name}\n#{content}\nend\n"
+      end
+
+      def namespace # :doc:
+        Rails::Generators.namespace
+      end
+
+      def namespaced? # :doc:
+        !options[:skip_namespace] && namespace
+      end
+
+      def namespace_dirs
+        @namespace_dirs ||= namespace.name.split("::").map(&:underscore)
+      end
+
+      def namespaced_path # :doc:
+        @namespaced_path ||= namespace_dirs.join("/")
+      end
+
+      # Use Rails default banner.
+      def self.banner # :doc:
+        "rails generate #{namespace.sub(/^rails:/, '')} #{arguments.map(&:usage).join(' ')} [options]".gsub(/\s+/, " ")
+      end
+
+      # Sets the base_name taking into account the current class namespace.
+      def self.base_name # :doc:
+        @base_name ||= begin
+          if base = name.to_s.split("::").first
+            base.underscore
+          end
+        end
+      end
+
+      # Removes the namespaces and get the generator name. For example,
+      # Rails::Generators::ModelGenerator will return "model" as generator name.
+      def self.generator_name # :doc:
+        @generator_name ||= begin
+          if generator = name.to_s.split("::").last
+            generator.sub!(/Generator$/, "")
+            generator.underscore
+          end
+        end
+      end
+
+      # Returns the default value for the option name given doing a lookup in
+      # Rails::Generators.options.
+      def self.default_value_for_option(name, options) # :doc:
+        default_for_option(Rails::Generators.options, name, options, options[:default])
+      end
+
+      # Returns default aliases for the option name given doing a lookup in
+      # Rails::Generators.aliases.
+      def self.default_aliases_for_option(name, options) # :doc:
+        default_for_option(Rails::Generators.aliases, name, options, options[:aliases])
+      end
+
+      # Returns default for the option name given doing a lookup in config.
+      def self.default_for_option(config, name, options, default) # :doc:
+        if generator_name && (c = config[generator_name.to_sym]) && c.key?(name)
+          c[name]
+        elsif base_name && (c = config[base_name.to_sym]) && c.key?(name)
+          c[name]
+        elsif config[:rails].key?(name)
+          config[:rails][name]
+        else
+          default
+        end
+      end
+
+      # Keep hooks configuration that are used on prepare_for_invocation.
+      def self.hooks #:nodoc:
+        @hooks ||= from_superclass(:hooks, {})
+      end
+
+      # Prepare class invocation to search on Rails namespace if a previous
+      # added hook is being used.
+      def self.prepare_for_invocation(name, value) #:nodoc:
+        return super unless value.is_a?(String) || value.is_a?(Symbol)
+
+        if value && constants = hooks[name]
+          value = name if TrueClass === value
+          Rails::Generators.find_by_namespace(value, *constants)
+        elsif klass = Rails::Generators.find_by_namespace(value)
+          klass
+        else
+          super
+        end
+      end
+
+      # Small macro to add ruby as an option to the generator with proper
+      # default value plus an instance helper method called shebang.
+      def self.add_shebang_option! # :doc:
+        class_option :ruby, type: :string, aliases: "-r", default: Thor::Util.ruby_command,
+                            desc: "Path to the Ruby binary of your choice", banner: "PATH"
+
+        no_tasks {
+          define_method :shebang do
+            @shebang ||= begin
+              command = if options[:ruby] == Thor::Util.ruby_command
+                "/usr/bin/env #{File.basename(Thor::Util.ruby_command)}"
+              else
+                options[:ruby]
+              end
+              "#!#{command}"
+            end
+          end
+        }
+      end
+
+      def self.usage_path # :doc:
+        paths = [
+          source_root && File.expand_path("../USAGE", source_root),
+          default_generator_root && File.join(default_generator_root, "USAGE")
+        ]
+        paths.compact.detect { |path| File.exist? path }
+      end
+
+      def self.default_generator_root # :doc:
+        path = File.expand_path(File.join(base_name, generator_name), base_root)
+        path if File.exist?(path)
+      end
+
+      def class_path # :doc:
+        inside_template? || !namespaced? ? regular_class_path : namespaced_class_path
+      end
+
+      def inside_template # :doc:
+        @inside_template = true
+        yield
+      ensure
+        @inside_template = false
+      end
+
+      def inside_template? # :doc:
+        @inside_template
+      end
+
+      def regular_class_path # :doc:
+        @class_path || []
+      end
+
+      def namespaced_class_path # :doc:
+        @namespaced_class_path ||= namespace_dirs + regular_class_path
       end
     end
   end

data/lib/generators/{validator → validacity}/validator_generator.rb

@@ -1,11 +1,10 @@
 module Validacity
   module Generators
-    class ValidacityGenerator < ::Rails::Generators::NamedBase
+    class ValidatorGenerator < ::Rails::Generators::NamedBase
       source_root File.expand_path("templates", __dir__)
 
       def create_validator
-        validator_file = File.join("app/validators",
-                                   class_path,
+        validator_file = File.join("app/validators", class_path,
                                    "#{file_name}_validator.rb")
         template "validator.rb", validator_file
       end

data/lib/validacity/validatable.rb

@@ -2,13 +2,35 @@ module Validacity
   module Validatable
     extend ActiveSupport::Concern
 
-    def valid?
+    class_methods do
+      def validations(*names)
+        names.each { |n| validacity_validators << n }
+      end
+
+      def validacity_validators
+        @_validacity_validators ||= Set.new
+      end
+
+      def new(resource)
+        instance = super
+        instance.validacity_validators.merge(validacity_validators.dup)
+        instance
+      end
+    end
+
+    def validacity_validators
+      @_validacity_validators ||= Set.new
+    end
+
+    def valid?(context = nil)
       super
-      validacity_validators_run
+      validacity_validators_run(context)
       errors.empty?
     end
 
-    def validacity_validators_run
+    private
+
+    def validacity_validators_run(_context = nil)
       each_validator_instance(&:validate)
     end
 
@@ -22,9 +44,5 @@ module Validacity
         yield(validator)
       end
     end
-
-    def validacity_validators
-      @_validacity_validators ||= Set.new
-    end
   end
 end

data/lib/validacity/version.rb

@@ -1,3 +1,3 @@
 module Validacity
-  VERSION = "0.1.0".freeze
+  VERSION = "0.2.0".freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: validacity
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Ivan Zinovyev
@@ -123,9 +123,8 @@ files:
 - Rakefile
 - lib/generators/validacity/install_generator.rb
 - lib/generators/validacity/templates/application_validator.rb
-- lib/generators/validator/templates/validator.rb
-- lib/generators/validator/validator_generator.rb
-- lib/tasks/validacity_tasks.rake
+- lib/generators/validacity/templates/validator.rb
+- lib/generators/validacity/validator_generator.rb
 - lib/validacity.rb
 - lib/validacity/base_validator.rb
 - lib/validacity/configuration.rb

data/lib/tasks/validacity_tasks.rake

@@ -1,4 +0,0 @@
-# desc "Explaining what the task does"
-# task :validacity do
-#   # Task goes here
-# end