zetto 2.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9f900c8afe4f24f4d55616172a6325e6fe4234b7
+  data.tar.gz: e11642fa9488e6caf62ce590417e80689dcfbb6c
+SHA512:
+  metadata.gz: 4a29b9afa0b0459f1f5f156fbd7069b84eed8e58616ffa4ba460e437a2c82567c93ba62c1592af7693775481c00f0af63b794ba0d54bf8def059bd4bdd721fba
+  data.tar.gz: c5b85f4470ddd779fe970c22f56206301554c1a06c728d175271ff931adfdd6a6776638ff11a46de1f072d111beac8b6e968ed4cba3aaad5cfc5733c44e61431

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 Ivan
+
+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.rdoc

@@ -0,0 +1,3 @@
+= Zetto
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,21 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+Bundler::GemHelper.install_tasks
+
+Dir[File.join(File.dirname(__FILE__), 'tasks/**/*.rake')].each {|f| load f }
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+desc "Run all specs in spec directory (excluding plugin specs)"
+RSpec::Core::RakeTask.new(:spec => 'app:db:test:prepare')
+
+task :default => :spec

data/lib/generators/active_record/templates/migration.erb

@@ -0,0 +1,11 @@
+class ZettoCreate<%= table_name.camelize %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :<%= table_name %> do |t|
+      t.string :name
+      t.text :description
+    end
+    <% migration_data.each do |name, properties| %>
+        add_column :<%= table_name %>, :<%= name %>, <%= properties %> unless column_exists? :<%= table_name %>, :<%= name %>
+    <% end %>
+  end
+end

data/lib/generators/active_record/templates/migration_existing.erb

@@ -0,0 +1,7 @@
+class AddZettoTo<%= table_name.camelize %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+    <% migration_data.each do |name, properties| %>
+        add_column :<%= table_name %>, :<%= name %>, <%= properties %> unless column_exists? :<%= table_name %>, :<%= name %>
+    <% end %>
+  end
+end

data/lib/generators/active_record/zetto_generator.rb

@@ -0,0 +1,59 @@
+require 'rails/generators/active_record'
+require 'generators/zetto/orm_helpers'
+require 'zetto/config/params'
+
+module ActiveRecord
+  module Generators
+
+    class ZettoGenerator < ActiveRecord::Generators::Base
+      argument :attributes, type: :array, default: [], banner: "field:type field:type"
+
+      include Zetto::Generators::OrmHelpers
+      source_root File.expand_path("../templates", __FILE__)
+
+      def add_zetto_migration
+        if (behavior == :invoke && model_exists?) || (behavior == :revoke && migration_exists?(table_name))
+          migration_template "migration_existing.erb", "db/migrate/add_zetto_to_#{table_name}.rb", migration_version: migration_version
+        else
+          migration_template "migration.erb", "db/migrate/zetto_create_#{table_name}.rb", migration_version: migration_version
+        end
+      end
+
+      def generate_model
+        invoke "active_record:model", [name], migration: false unless model_exists? && behavior == :invoke
+      end
+
+      def inject_zetto_model_content
+        content = model_contents
+
+        class_path = namespaced? ? class_name.to_s.split("::") : [class_name]
+
+        indent_depth = class_path.size - 1
+        content = content.split("\n").map { |line| "  " * indent_depth + line }.join("\n") << "\n"
+
+        inject_into_class(model_path, class_path.last, content) if model_exists?
+      end
+
+      def migration_data
+        fields = {}
+        key = Zetto::Config::Params.user_class_name
+        fields[key] = ":string,  :null => false, default: ''"
+        key = Zetto::Config::Params.user_class_password
+        fields[key] = ":string,  :null => false, default: ''"
+        fields
+      end
+
+      def rails5?
+        Rails.version.start_with? '5'
+      end
+
+      def migration_version
+        if rails5?
+          "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
+        end
+      end
+
+    end
+
+  end
+end

data/lib/generators/zetto/install_generator.rb

@@ -0,0 +1,15 @@
+require 'rails/generators'
+module Zetto
+  class InstallGenerator < Rails::Generators::Base
+    desc "Some description of my generator here"
+
+    def self.source_root
+      @source_root ||= File.join(File.dirname(__FILE__), 'templates')
+    end
+
+    def copy_initializer
+      template "zetto.rb", "config/initializers/zetto.rb"
+    end
+    
+  end
+end

data/lib/generators/zetto/orm_helpers.rb

@@ -0,0 +1,30 @@
+module Zetto
+  module Generators
+    module OrmHelpers
+      def model_contents
+        buffer = <<-CONTENT
+          zetto :authentication
+        CONTENT
+        buffer
+      end
+
+      private
+
+      def model_exists?
+        File.exist?(File.join(destination_root, model_path))
+      end
+
+      def migration_exists?(table_name)
+        Dir.glob("#{File.join(destination_root, migration_path)}/[0-9]*_*.rb").grep(/\d+_add_devise_to_#{table_name}.rb$/).first
+      end
+
+      def migration_path
+        @migration_path ||= File.join("db", "migrate")
+      end
+
+      def model_path
+        @model_path ||= File.join("app", "models", "#{file_path}.rb")
+      end
+    end
+  end
+end

data/lib/generators/zetto/templates/zetto.rb

@@ -0,0 +1,37 @@
+# Add extension
+require "zetto/load"
+# Simple generator for rails
+Zetto.setup do |config|
+
+  # Список пользовательских классов
+  config.user_classes = ['User']
+  # Поиск сесиии по этим полям
+  config.user_class_name     = 'email'
+  config.user_class_password = 'password'
+
+  # Длинна пароля, больше чем
+  config.user_class_password_length_larger = 6
+
+  # Хешировать пароль с помощью
+  # ['MD5', 'SHA1', 'RMD160', 'SHA256', 'SHA384', 'SHA512']
+  config.user_class_password_crypto = 'SHA1'
+
+  # Настройки для подключения к бд redis, не используем 0 бд, так-как она предназначается для тестовых нужд
+  config.redis_connect = {:password => "", "db" => 1}
+
+  # Чем больше тем надежнее, но будет медленее поиск
+  config.session_length = 9
+
+  # Время жизни сесии
+  config.session_time_min = 30
+
+  # За сколько минут перегенирировать
+  config.session_time_restart_min = 5
+
+  # Ведет лог посещений пользователей
+  config.log = false
+
+  # Можно настроить сессию на ип, что повысит стойкость, но имеем проблемы для людей с динамическим ип, в некоторых случаях
+  config.check_ip = false
+
+end

data/lib/generators/zetto/zetto_generator.rb

@@ -0,0 +1,17 @@
+require 'rails/generators/named_base'
+
+module Zetto
+  module Generators
+    class ZettoGenerator < Rails::Generators::NamedBase
+      include Rails::Generators::ResourceHelpers
+
+      namespace "zetto"
+      source_root File.expand_path("../templates", __FILE__)
+
+      desc "Create table or add need field if table exist"
+
+      hook_for :orm
+
+    end
+  end
+end

data/lib/zetto.rb

@@ -0,0 +1,11 @@
+require "zetto/engine"
+require "zetto/config/params"
+
+module Zetto
+
+  def self.setup(&block)
+    I18n.load_path += Dir[File.join(File.dirname(__FILE__), 'zetto/locales', '*.yml').to_s]
+    Zetto::Config::Params.set_params(&block)
+  end
+
+end

data/lib/zetto/config/params.rb

@@ -0,0 +1,80 @@
+module Zetto
+  module Config
+
+    module Params
+
+      CRYPTO_ALGORITHMS = ['MD5', 'SHA1', 'RMD160', 'SHA256', 'SHA384', 'SHA512']
+
+      @user_classes = ['User']
+
+      @user_class_name                   = 'email'
+      @user_class_password               = 'password'
+      @user_class_password_length_larger = 6
+      @user_class_password_crypto        = 'SHA1'
+      @check_ip                          = false
+      @log                               = false
+      
+      @redis_connect = {:password => "", "db" => 1}
+
+      @session_length = 9
+      @session_time_min = 30
+      @session_time_restart_min = 5
+
+      class << self
+
+        def self.attr_writer_with_type(type, *args)
+          args.each do |arg|
+            self.send(:define_method, "#{arg}=".intern) do |value|
+              unless value.class.to_s == type
+                raise ArgumentError.new(I18n.t('exseptions.not_specified_type', arg: arg, type: type, class_name: value.class.to_s))
+              end
+              instance_variable_set("@#{arg}", value)
+            end
+          end
+        end
+
+        attr_writer :check_ip, :log
+        attr_writer_with_type 'Fixnum',  :session_time_restart_min, :session_time_min, :session_length, :user_class_password_length_larger
+        attr_writer_with_type 'Hash',    :redis_connect
+        attr_writer_with_type 'String',  :user_class_name, :user_class_password
+
+        attr_reader :user_class_password_crypto, :check_ip, :log, :session_time_restart_min, :session_time_min, :session_length, :user_class_password_length_larger, :redis_connect,
+                    :user_class_name, :user_class_password
+
+        def set_params
+          yield self
+        end
+
+        def user_class_password_crypto=(value)
+          value = value.to_s.upcase
+          unless self::CRYPTO_ALGORITHMS.include?(value)
+            raise ArgumentError.new(I18n.t('exseptions.unknown_algorithm', algorithm: value.to_s ))
+          end
+          @user_class_password_crypto = value
+        end
+
+        def user_classes=(arr)
+          @user_classes = arr.map{ |class_name| class_name.to_s.capitalize  }
+        end
+
+        def user_class(class_str)
+          begin
+            unless @user_classes.include?(class_str)
+              raise ArgumentError.new(I18n.t('exseptions.unknown_target_class', class_name: class_str.to_s ))
+            end
+            class_str.constantize
+          rescue Exception => e
+            puts e.message
+            nil
+          end
+        end
+
+      end
+    end
+
+  end
+end
+
+
+
+

data/lib/zetto/engine.rb

@@ -0,0 +1,16 @@
+module Zetto
+
+  class Engine < ::Rails::Engine
+    isolate_namespace Zetto
+
+    config.generators do |g|
+      g.test_framework :rspec, :fixture => false
+      g.fixture_replacement :factory_girl, :dir => 'spec/factories'
+      g.assets false
+      g.helper false
+    end
+
+  end
+end
+
+

data/lib/zetto/extension/action_controller_base.rb

@@ -0,0 +1,54 @@
+module Zetto::Extension::ActionControllerBase
+  extend ActiveSupport::Concern
+  require "zetto/config/params"
+
+  require "zetto/storage/common/load"
+  require "zetto/storage/connect/load"
+  require "zetto/storage/impurety_data/load"
+  require "zetto/storage/session/load"
+
+  require "zetto/modules/load"
+
+  require "zetto/services/encryption/load"
+  require "zetto/services/cookie/load"
+  require "zetto/services/session/load"
+  require "zetto/services/authentication/load"
+
+
+  included do
+
+    def current_user
+      begin
+        Zetto::Services::Session::GetUser.new(cookies, request.user_agent, request.remote_ip).execute
+      rescue ArgumentError => e
+        Zetto::Services::Info.error_message I18n.t('exseptions.invalid_arguments', argument: 'Zetto::ControllerMethods', current_method: __method__), e
+        nil
+      rescue Exception => e
+        Zetto::Services::Info.error_message I18n.t('exseptions.unknown_error', argument: 'Zetto::ControllerMethods', current_method: __method__), e
+        nil
+      end
+    end
+
+    def authorization(class_name, name, password)
+      begin
+        hashed_password = Zetto::Services::Encryption::PasswordHashing.new(password).execute
+        user = Zetto::Services::Authentication::FindUser.new(class_name, name, hashed_password).execute
+        return nil if user.nil?
+        return nil if user.new_record?
+        Zetto::Services::Session::Registration.new(user, cookies, request.user_agent, request.remote_ip).execute
+      rescue ArgumentError => e
+        Zetto::Services::Info.error_message I18n.t('exseptions.invalid_arguments', argument: 'Zetto::ControllerMethods', current_method: __method__), e
+        nil
+      rescue Exception => e
+        Zetto::Services::Info.error_message I18n.t('exseptions.unknown_error', argument: 'Zetto::ControllerMethods', current_method: __method__), e
+        nil
+      end
+    end
+
+    def logout
+      @cookies[:rembo] = nil
+    end
+
+  end
+
+end

data/lib/zetto/extension/active_record.rb

@@ -0,0 +1,60 @@
+
+
+module Zetto::Extension::ActiveRecord
+  extend ActiveSupport::Concern
+  require "zetto/modules/load"
+  require "zetto/services/encryption/load"
+
+  included do
+
+    protected
+
+    def password_confirmed
+      begin
+        password_field  = Zetto::Config::Params.user_class_password
+        password_value  = send(password_field).to_s
+        errors.add(password_field.intern, I18n.t('validate.password_confirm')) unless password_value == password_confirmation
+
+        password_confirmation
+      rescue Exception => e
+        Zetto::Services::Info.error_message I18n.t('exseptions.undefined_field', field: password_field), e
+      end
+    end
+
+    def password_encryption
+      begin
+        password_field  = Zetto::Config::Params.user_class_password
+        password_value  = send(password_field)
+        hashed_password = Zetto::Services::Encryption::PasswordHashing.new(password_value).execute
+        send(password_field+'=', hashed_password)
+      rescue Exception => e
+        Zetto::Services::Info.error_message I18n.t('exseptions.undefined_field', field: password_field), e
+      end
+    end
+
+  end
+
+  class_methods do
+
+    def zetto(method)
+      method_name = 'zetto_' + method.to_s
+      self.send(method_name) if 'zetto_authentication' == method_name
+    end
+
+    protected
+
+    def zetto_authentication
+      attr_accessor :password_confirmation
+      validates      Zetto::Config::Params.user_class_name.intern, uniqueness:true
+      validates      Zetto::Config::Params.user_class_password.intern, presence: true,
+                     length: { minimum: Zetto::Config::Params.user_class_password_length_larger }
+
+      validate      :password_confirmed
+      before_save   :password_encryption
+    end
+
+  end
+
+end
+
+