pd1_tools 0.43.0

data/lib/avmtrf1/node_js/docker_image.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'avmtrf1/docker/image'
+
+module Avmtrf1
+  module NodeJs
+    class DockerImage < ::Avmtrf1::Docker::Image
+      # @return [String]
+      def apt_setup
+        debian_stretch_apt_setup.gsub('-y dist-upgrade', '-y --allow-unauthenticated dist-upgrade')
+      end
+    end
+  end
+end

data/lib/avmtrf1/node_js.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avmtrf1
+  module NodeJs
+    require_sub __FILE__
+  end
+end

data/lib/avmtrf1/openvpn/config/builder.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'avmtrf1/openvpn/config/parser'
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/fs/temp'
+
+module Avmtrf1
+  module Openvpn
+    module Config
+      class Builder
+        common_constructor :source_data do
+          unless source_data.is_a?(::Hash)
+            self.source_data = ::Avmtrf1::Openvpn::Config::Parser.new(source_data.to_s).data
+          end
+        end
+
+        def data
+          [simple, tags].reject(&:blank?).join("\n")
+        end
+
+        def on_data_file
+          ::EacRubyUtils::Fs::Temp.on_file do |file|
+            file.write(data)
+            yield(file)
+          end
+        end
+
+        def simple
+          source_data.fetch(:simple)
+            .map { |s| ::Shellwords.join([s.fetch(:attribute)] + s.fetch(:args)) }
+            .map { |s| "#{s}\n" }.join
+        end
+
+        def simple_add_or_update(name, args)
+          new_data = { attribute: name, args: args }
+          s = simple_find(name)
+          if s
+            s.merge!(new_data)
+          else
+            source_data.fetch(:simple) << new_data
+          end
+        end
+
+        def tags
+          source_data.fetch(:tags).map { |t| tag_to_data(t) }
+        end
+
+        def tag_to_data(tag)
+          ["<#{tag.fetch(:name)}>", tag.fetch(:content), "</#{tag.fetch(:name)}>"]
+            .map { |v| "#{v}\n" }.join
+        end
+
+        def simple_find(name)
+          source_data.fetch(:simple).find { |s| s.fetch(:attribute) == name }
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/openvpn/config/parser/builder.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'avmtrf1/openvpn/config/parser/line'
+require 'avmtrf1/openvpn/config/parser/simple'
+require 'avmtrf1/openvpn/config/parser/tag'
+
+module Avmtrf1
+  module Openvpn
+    module Config
+      class Parser < ::Aranha::Parsers::Base
+        class Builder
+          attr_reader :simple, :tags
+
+          def initialize
+            @simple = []
+            @tags = []
+          end
+
+          def add_line(line_text)
+            line = ::Avmtrf1::Openvpn::Config::Parser::Line.new(line_text)
+            if on_tag?
+              add_line_on_tag(line)
+            else
+              add_line_not_on_tag(line)
+            end
+          end
+
+          def add_line_on_tag(line)
+            if line.close_tag?
+              if line.tag_name != current_tag.name
+                raise("Closing tag \"#{line.tag_name}\" does not match current tag " \
+                      "\"#{current_tag}\"")
+              end
+
+              current_tag.close
+            else
+              current_tag.add_line(line.text)
+            end
+          end
+
+          def add_line_not_on_tag(line)
+            return if line.blank_text?
+
+            if line.open_tag?
+              tags << ::Avmtrf1::Openvpn::Config::Parser::Tag.new(line.tag_name)
+            else
+              simple << ::Avmtrf1::Openvpn::Config::Parser::Simple.new(line.simple_parts)
+            end
+          end
+
+          def current_tag
+            tags.last
+          end
+
+          def on_tag?
+            tags.last.if_present(false, &:open?)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/openvpn/config/parser/line.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avmtrf1
+  module Openvpn
+    module Config
+      class Parser < ::Aranha::Parsers::Base
+        class Line
+          OPEN_TAG_PATTERN = /\A<(.+)>\z/.freeze
+          CLOSE_TAG_PATTERN = %r{\A</(.+)>\z}.freeze
+          SIMPLE_PATTERN = /\A(\S+)(?:\s+(\S.*))\z/.freeze
+
+          common_constructor :text do
+            self.text = text.rstrip
+          end
+
+          def simple_parts
+            ::Shellwords.split(text)
+          end
+
+          def blank_text?
+            text.blank?
+          end
+
+          def open_tag?
+            OPEN_TAG_PATTERN.match?(text)
+          end
+
+          def close_tag?
+            CLOSE_TAG_PATTERN.match?(text)
+          end
+
+          def tag_name
+            if close_tag?
+              CLOSE_TAG_PATTERN.if_match(text) { |m| m[1] }
+            elsif open_tag?
+              OPEN_TAG_PATTERN.if_match(text) { |m| m[1] }
+            else
+              raise "Unmapped branch in #{__method__}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/openvpn/config/parser/simple.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avmtrf1
+  module Openvpn
+    module Config
+      class Parser < ::Aranha::Parsers::Base
+        class Simple
+          common_constructor :parts
+
+          def data
+            { attribute: attribute, args: args }
+          end
+
+          def attribute
+            parts.first
+          end
+
+          def args
+            parts[1..-1] # rubocop:disable Style/SlicingWithRange
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/openvpn/config/parser/tag.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avmtrf1
+  module Openvpn
+    module Config
+      class Parser < ::Aranha::Parsers::Base
+        class Tag
+          common_constructor :name do
+            @open = true
+          end
+
+          def add_line(text)
+            lines << text
+          end
+
+          def data
+            { name: name, content: lines.join("\n") }
+          end
+
+          def open?
+            @open
+          end
+
+          def close
+            @open = false
+          end
+
+          private
+
+          def lines
+            @lines ||= []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/openvpn/config/parser.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'aranha/parsers/base'
+require 'eac_ruby_utils/core_ext'
+
+module Avmtrf1
+  module Openvpn
+    module Config
+      class Parser < ::Aranha::Parsers::Base
+        require_sub __FILE__
+
+        def data
+          builder = ::Avmtrf1::Openvpn::Config::Parser::Builder.new
+          content.each_line { |line| builder.add_line(line) }
+          { simple: builder.simple.map(&:data), tags: builder.tags.map(&:data) }
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/oracle/connection/base.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'avmtrf1/oracle/objects'
+require 'avmtrf1/oracle/oci8'
+
+module Avmtrf1
+  module Oracle
+    module Connection
+      class Base
+        DEFAULT_PORT = 1521
+
+        delegate :exec, to: :connection
+
+        def initialize(connection_string)
+          ::Avmtrf1::Oracle::Oci8.require_lib
+          @connection = OCI8.new(connection_string)
+        end
+
+        def first_row(sql)
+          connection.exec(sql) { |row| return row }
+          nil
+        end
+
+        def first_row_hash(sql)
+          connection.exec(sql).fetch_hash { |row| return row }
+          nil
+        end
+
+        def unique_value(sql)
+          first_row(sql).if_present(&:first)
+        end
+
+        def query(sql, &block)
+          if block
+            query_with_block(sql, block)
+          else
+            query_without_block(sql)
+          end
+        end
+
+        def objects
+          @objects ||= ::Avmtrf1::Oracle::Objects.new(self)
+        end
+
+        private
+
+        attr_reader :connection
+
+        def query_without_block(sql)
+          connection.exec(sql)
+        end
+
+        def query_with_block(sql, block)
+          cursor = query_without_block(sql)
+          begin
+            while (row = cursor.fetch_hash)
+              block.call(row)
+            end
+          ensure
+            cursor.close
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/oracle/connection/string_builder.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Avmtrf1
+  module Oracle
+    module Connection
+      class StringBuilder
+        DEFAULT_PORT = 1521
+
+        FIELDS = %w[user password host port service_name].freeze
+
+        attr_accessor(*FIELDS, :string)
+
+        def initialize(options = nil)
+          if options.is_a?(String)
+            self.string = options
+          elsif options.is_a?(Hash)
+            options.each do |k, v|
+              send("#{k}=", v)
+            end
+          end
+        end
+
+        def port
+          @port || DEFAULT_PORT
+        end
+
+        def build
+          if string
+            string
+          else
+            validate_fields
+            "#{user}/#{password}@//#{host}:#{port}/#{service_name}"
+          end
+        end
+
+        private
+
+        def validate_fields
+          FIELDS.each { |f| raise "\"#{f}\" is blank" if send(f).blank? }
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/oracle/connection.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+Dir["#{File.dirname(__FILE__)}/#{File.basename(__FILE__, '.*')}/*.rb"].sort.each do |path|
+  require path
+end
+
+module Avmtrf1
+  module Oracle
+    module Connection
+    end
+  end
+end

data/lib/avmtrf1/oracle/object/base.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/listable'
+
+module Avmtrf1
+  module Oracle
+    class Object
+      class Base
+        include ::EacRubyUtils::Listable
+
+        lists.add_string :attributes, :id, :name, :owner, :type
+        common_constructor :connection, :attributes
+
+        lists.attributes.values.each do |attribute| # rubocop:disable Style/HashEachMethods
+          define_method(attribute) do
+            attributes.fetch(attribute.to_sym)
+          end
+        end
+
+        def drop
+          connection.exec(drop_ddl)
+        end
+
+        def fullname
+          (owner.present? ? "#{owner}." : '') + name
+        end
+
+        def to_s
+          "#{type}/#{fullname}"
+        end
+
+        def drop_ddl
+          "drop #{type} #{fullname}"
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/oracle/object/table.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'avmtrf1/oracle/object/base'
+
+module Avmtrf1
+  module Oracle
+    class Object
+      class Table < ::Avmtrf1::Oracle::Object::Base
+        def drop_ddl
+          "#{super} cascade constraints"
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/oracle/object/user.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'avmtrf1/oracle/object/base'
+
+module Avmtrf1
+  module Oracle
+    class Object
+      class User < ::Avmtrf1::Oracle::Object::Base
+        def objects(search_attributes = {})
+          connection.objects.list(search_attributes.merge(owner: name))
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/oracle/object/view.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'avmtrf1/oracle/object/base'
+
+module Avmtrf1
+  module Oracle
+    class Object
+      class View < ::Avmtrf1::Oracle::Object::Base
+        def drop_ddl
+          "#{super} cascade constraints"
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/oracle/object.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avmtrf1
+  module Oracle
+    class Object
+      require_sub __FILE__
+
+      class << self
+        def factory_get(connection, attributes)
+          return nil if attributes.blank?
+
+          type_class(attributes.fetch(:type)).new(connection, attributes)
+        end
+
+        def type_class(type)
+          const_get(type.to_s.humanize.camelize)
+        rescue NameError
+          ::Avmtrf1::Oracle::Object::Base
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/oracle/objects/relation.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avmtrf1
+  module Oracle
+    class Objects
+      class Relation
+        common_constructor :connection, :sql
+
+        def each
+          connection.query(sql).fetch_hash do |row|
+            yield(::Avmtrf1::Oracle::Objects.row_to_object(connection, row))
+          end
+        end
+
+        def count
+          connection.unique_value("select * from (#{sql})").to_i
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/oracle/objects/sql_builder.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avmtrf1
+  module Oracle
+    class Objects
+      class SqlBuilder
+        COLUMNS = {
+          type: :type_name, name: :name, owner: :owner_name, table: :table_name
+        }.freeze
+
+        enable_simple_cache
+        common_constructor :options
+
+        def sql
+          "SELECT * FROM (\n" + # rubocop:disable Style/StringConcatenation
+            [all_objects_sql, all_users_sql].map { |sub_sql| "\t(#{with_where_sql(sub_sql)})\n" }
+              .join("\tUNION ALL\n") +
+            ") order by object_type, owner, object_name\n"
+        end
+
+        def all_objects_sql
+          "SELECT #{COLUMNS_TO_ATTRIBUTES.keys.join(', ')} FROM #{TABLE_NAME}"
+        end
+
+        def all_users_sql
+          'SELECT user_id as object_id, username as object_name, \'USER\' as object_type' \
+            ', null as owner FROM all_users'
+        end
+
+        def with_where_sql(sql)
+          r = "select * from (#{sql}) WHERE 1=1"
+          COLUMNS_TO_ATTRIBUTES.each_value do |search_key|
+            search_option_condition(search_key).if_present do |v|
+              r += " and (#{v})"
+            end
+          end
+          r
+        end
+
+        def column_by_search_key(search_key)
+          COLUMNS_TO_ATTRIBUTES.key(search_key) || raise("Search key not found: #{search_key}")
+        end
+
+        def search_option_condition(search_key)
+          values = search_option(search_key)
+          return nil unless values.any?
+
+          column = column_by_search_key(search_key)
+          values.map { |v| "(LOWER(#{column}) LIKE LOWER('#{v}'))" }.join(' or ')
+        end
+
+        def search_option(search_key)
+          [search_key.to_s, search_key.to_sym].each do |k|
+            v = options[k]
+            return Array(v) if v.present?
+          end
+          []
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/oracle/objects.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avmtrf1
+  module Oracle
+    class Objects
+      require_sub __FILE__
+
+      COLUMNS_TO_ATTRIBUTES = {
+        object_id: :id,
+        object_name: :name,
+        object_type: :type,
+        owner: :owner
+      }.freeze
+      TABLE_NAME = 'all_objects'
+
+      class << self
+        def row_to_object(connection, row)
+          ::Avmtrf1::Oracle::Object.factory_get(
+            connection,
+            row_to_attributes(row)
+          )
+        end
+
+        def row_to_attributes(row)
+          return nil if row.blank?
+
+          COLUMNS_TO_ATTRIBUTES.map do |column, attribute| # rubocop:disable Style/MapToHash
+            [attribute, row.fetch(column.to_s.upcase)]
+          end.to_h
+        end
+      end
+
+      common_constructor :connection
+
+      def list(options = {})
+        ::Avmtrf1::Oracle::Objects::Relation.new(connection, sql(options))
+      end
+
+      def first(options = {})
+        self.class.row_to_object(
+          connection,
+          connection.first_row_hash(sql(options))
+        )
+      end
+
+      def sql(options)
+        ::Avmtrf1::Oracle::Objects::SqlBuilder.new(options).sql
+      end
+    end
+  end
+end

data/lib/avmtrf1/oracle/oci8.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'avmtrf1/tools/rubygems/dependency'
+
+module Avmtrf1
+  module Oracle
+    module Oci8
+      NLS_LANG_DEFAULT_VALUE = 'BRAZILIAN PORTUGUESE_BRAZIL.UTF8'
+      NLS_LANG_ENVIRONMENT_KEY = 'NLS_LANG'
+
+      class << self
+        def dependency
+          @dependency ||= ::Avmtrf1::Tools::Rubygems::Dependency.new('ruby-oci8', 'oci8')
+        end
+
+        def require_lib
+          nls_lang_set
+          dependency.require_lib
+        end
+
+        def nls_lang_set
+          return if ENV.key?(NLS_LANG_ENVIRONMENT_KEY)
+
+          ENV[NLS_LANG_ENVIRONMENT_KEY] = NLS_LANG_DEFAULT_VALUE
+        end
+      end
+    end
+  end
+end