torque-postgresql 0.1.0

data/lib/torque/postgresql/adapter.rb

@@ -0,0 +1,29 @@
+
+require_relative 'adapter/database_statements'
+require_relative 'adapter/oid'
+require_relative 'adapter/quoting'
+require_relative 'adapter/schema_definitions'
+require_relative 'adapter/schema_dumper'
+require_relative 'adapter/schema_statements'
+
+module Torque
+  module PostgreSQL
+    module Adapter
+
+      include Quoting
+      include ColumnDumper
+      include DatabaseStatements
+      include SchemaStatements
+
+      # Get the current PostgreSQL version as a Gem Version.
+      def version
+        @version ||= Gem::Version.new(
+          select_value('SELECT version()')
+            .match(/#{Adapter::ADAPTER_NAME} ([\d\.]+)/)[1])
+      end
+
+    end
+
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.prepend Adapter
+  end
+end

data/lib/torque/postgresql/attributes/builder/enum.rb

@@ -0,0 +1,151 @@
+module Torque
+  module PostgreSQL
+    module Attributes
+      module Builder
+        class Enum
+
+          attr_accessor :klass, :attribute, :subtype, :initial, :options, :values
+
+          # Start a new builder of methods for composite values on
+          # ActiveRecord::Base
+          def initialize(klass, attribute, subtype, initial, options)
+            @klass     = klass
+            @attribute = attribute.to_s
+            @subtype   = subtype
+            @initial   = initial
+            @options   = options
+
+            @values    = subtype.klass.values
+
+            if @options[:only]
+              @values &= Array(@options[:only]).map(&:to_s)
+            end
+
+            if @options[:except]
+              @values -= Array(@options[:except]).map(&:to_s)
+            end
+          end
+
+          # Get the list of methods based on enum values
+          def values_methods
+            return @values_methods if defined?(@values_methods)
+
+            prefix = options.fetch(:prefix, nil).try(:<<, '_')
+            suffix = options.fetch(:suffix, nil).try(:prepend, '_')
+
+            prefix = attribute + '_' if prefix == true
+            suffix = '_' + attribute if suffix == true
+
+            base   = "#{prefix}%s#{suffix}"
+
+            @values_methods = begin
+              values.map do |val|
+                val   = val.tr('-', '_')
+                scope = base % val
+                ask   = scope + '?'
+                bang  = scope + '!'
+                [val, [scope, ask, bang]]
+              end.to_h
+            end
+          end
+
+          # Check if any of the methods that will be created get in conflict
+          # with the base class methods
+          def conflicting?
+            return false if options[:force] == true
+
+            dangerous?(attribute.pluralize, true)
+            dangerous?(attribute + '_text')
+
+            values_methods.each do |attr, list|
+              list.map(&method(:dangerous?))
+            end
+
+            return false
+          rescue Interrupt => err
+            if !initial
+              raise ArgumentError, <<-MSG.gsub(/^ +| +$|\n/, '')
+                #{subtype.class.name} was not able to generate requested
+                methods because the method #{err} already exists in
+                #{klass.name}.
+              MSG
+            else
+              warn <<-MSG.gsub(/^ +| +$|\n/, '')
+                #{subtype.class.name} was not able to autoload on
+                #{klass.name} because the method #{err} already exists.
+              MSG
+              return true
+            end
+          end
+
+          # Create all methods needed
+          def build
+            plural
+            text
+            all_values
+          end
+
+          private
+
+            # Check if the method already exists in the reference class
+            def dangerous?(method_name, class_method = false)
+              if class_method
+                if klass.dangerous_class_method?(method_name)
+                  raise Interrupt, method_name.to_s
+                end
+              else
+                if klass.dangerous_attribute_method?(method_name)
+                  raise Interrupt, method_name.to_s
+                end
+              end
+            end
+
+            # Create the method that allow access to the list of values
+            def plural
+              klass.singleton_class.module_eval <<-STR, __FILE__, __LINE__ + 1
+                def #{attribute.pluralize}                  # def statuses
+                  ::#{subtype.klass.name}.values            #   ::Enum::Status.values
+                end                                         # end
+              STR
+            end
+
+            # Create the method that turn the attribute value into text using
+            # the model scope
+            def text
+              klass.module_eval <<-STR, __FILE__, __LINE__ + 1
+                def #{attribute}_text                       # def status_text
+                  #{attribute}.text('#{attribute}', self)   #   status.text('status', self)
+                end                                         # end
+              STR
+            end
+
+            # Create all the methods that represent actions related to the
+            # attribute value
+            def all_values
+              values_methods.each do |val, list|
+                klass.singleton_class.module_eval <<-STR, __FILE__, __LINE__ + 1
+                  def #{list[0]}                            # def disabled
+                    where(#{attribute}: '#{val}')           #   where(status: 'disabled')
+                  end                                       # end
+                STR
+                klass.module_eval <<-STR, __FILE__, __LINE__ + 1
+                  def #{list[1]}                            # def disabled?
+                    #{attribute}.#{val}?                    #   status.disabled?
+                  end                                       # end
+
+                  def #{list[2]}                            # def disabled!
+                    if enum_save_on_bang                    #   if enum_save_on_bang
+                      update!(#{attribute}: '#{val}')       #     update!(status: 'disabled')
+                    else                                    #   else
+                      #{attribute}.#{val}!                  #     status.disabled!
+                    end                                     #   end
+                  end                                       # end
+                STR
+              end
+            end
+
+        end
+      end
+    end
+  end
+end

data/lib/torque/postgresql/attributes/builder.rb

@@ -0,0 +1 @@
+require_relative 'builder/enum'

data/lib/torque/postgresql/attributes/enum.rb

@@ -0,0 +1,231 @@
+module Torque
+  module PostgreSQL
+    module Attributes
+      class Enum < String
+        include Comparable
+
+        class EnumError < ArgumentError; end
+
+        LAZY_VALUE = 0.chr
+
+        class << self
+          delegate :each, to: :values
+
+          # Find or create the class that will handle the value
+          def lookup(name)
+            const     = name.camelize
+            namespace = Torque::PostgreSQL.config.enum.namespace
+
+            return namespace.const_get(const) if namespace.const_defined?(const)
+            namespace.const_set(const, Class.new(Enum))
+          end
+
+          # You can specify the connection name for each enum
+          def connection_specification_name
+            return self == Enum ? 'primary' : superclass.connection_specification_name
+          end
+
+          # Overpass new so blank values return only nil
+          def new(value)
+            return Lazy.new(self, LAZY_VALUE) if value.blank?
+            super
+          end
+
+          # Load the list of values in a lazy way
+          def values
+            @values ||= self == Enum ? nil : begin
+              conn_name = connection_specification_name
+              conn = connection(conn_name)
+              conn.enum_values(type_name)
+            end
+          end
+
+          # Fetch a value from the list
+          # see https://github.com/rails/rails/blob/v5.0.0/activerecord/lib/active_record/fixtures.rb#L656
+          # see https://github.com/rails/rails/blob/v5.0.0/activerecord/lib/active_record/validations/uniqueness.rb#L101
+          def fetch(value, *)
+            return nil unless values.include?(value)
+            send(value)
+          end
+          alias [] fetch
+
+          # Get the type name from its class name
+          def type_name
+            @type_name ||= self.name.demodulize.underscore
+          end
+
+          # Check if the value is valid
+          def valid?(value)
+            return false if self == Enum
+            return true if value.equal?(LAZY_VALUE)
+            self.values.include?(value.to_s)
+          end
+
+          private
+
+            # Allows checking value existance
+            def respond_to_missing?(method_name, include_private = false)
+              valid?(method_name)
+            end
+
+            # Allow fast creation of values
+            def method_missing(method_name, *arguments)
+              return super if self == Enum
+              self.valid?(method_name) ? new(method_name.to_s) : super
+            end
+
+            # Get a connection based on its name
+            def connection(name)
+              ActiveRecord::Base.connection_handler.retrieve_connection(name)
+            end
+
+        end
+
+        # Extension of the ActiveRecord::Base to initiate the enum features
+        module Base
+
+          method_name = Torque::PostgreSQL.config.enum.base_method
+          module_eval <<-STR, __FILE__, __LINE__ + 1
+            def #{method_name}(*args, **options)
+              args.each do |attribute|
+                type = attribute_types[attribute.to_s]
+                TypeMap.lookup(type, self, attribute.to_s, false, options)
+              end
+            end
+          STR
+
+        end
+
+        # Override string initializer to check for a valid value
+        def initialize(value)
+          str_value = value.is_a?(Numeric) ? self.class.values[value.to_i] : value.to_s
+          raise_invalid(value) unless self.class.valid?(str_value)
+          super(str_value)
+        end
+
+        # Allow comparison between values of the same enum
+        def <=>(other)
+          raise_comparison(other) if other.is_a?(Enum) && other.class != self.class
+
+          case other
+          when Numeric, Enum  then to_i <=> other.to_i
+          when String, Symbol then to_i <=> self.class.values.index(other.to_s)
+          else raise_comparison(other)
+          end
+        end
+
+        # Only allow value comparison with values of the same class
+        def ==(other)
+          (self <=> other) == 0
+        rescue EnumError
+          false
+        end
+        alias eql? ==
+
+        # Since it can have a lazy value, nil can be true here
+        def nil?
+          self == LAZY_VALUE
+        end
+        alias empty? nil?
+
+        # It only accepts if the other value is valid
+        def replace(value)
+          raise_invalid(value) unless self.class.valid?(value)
+          super
+        end
+
+        # Get a translated version of the value
+        def text(attr = nil, model = nil)
+          keys = i18n_keys(attr, model) << self.underscore.humanize
+          I18n.t(keys.shift, default: keys)
+        end
+
+        # Change the string result for lazy value
+        def to_s
+          nil? ? '' : super
+        end
+
+        # Get the index of the value
+        def to_i
+          self.class.values.index(self)
+        end
+
+        # Change the inspection to show the enum name
+        def inspect
+          nil? ? 'nil' : "#<#{self.class.name} #{super}>"
+        end
+
+        private
+
+          # Get the i18n keys to check
+          def i18n_keys(attr = nil, model = nil)
+            values = { type: self.class.type_name, value: to_s }
+            list_from = :i18n_type_scopes
+
+            if attr && model
+              values[:attr] = attr
+              values[:model] = model.class.model_name.i18n_key
+              list_from = :i18n_scopes
+            end
+
+            Torque::PostgreSQL.config.enum.send(list_from).map do |key|
+              (key % values).to_sym
+            end
+          end
+
+          # Check for valid '?' and '!' methods
+          def respond_to_missing?(method_name, include_private = false)
+            name = method_name.to_s
+
+            return true if name.chomp!('?')
+            name.chomp!('!') && self.class.valid?(name)
+          end
+
+          # Allow '_' to be associated to '-'
+          def method_missing(method_name, *arguments)
+            name = method_name.to_s
+
+            if name.chomp!('?')
+              self == name.tr('_', '-') || self == name
+            elsif name.chomp!('!')
+              replace(name)
+            else
+              super
+            end
+          end
+
+          # Throw an exception for invalid valus
+          def raise_invalid(value)
+            if value.is_a?(Numeric)
+              raise EnumError, "#{value.inspect} is out of bounds of #{self.class.name}"
+            else
+              raise EnumError, "#{value.inspect} is not valid for #{self.class.name}"
+            end
+          end
+
+          # Throw an exception for comparasion between different enums
+          def raise_comparison(other)
+            raise EnumError, "Comparison of #{self.class.name} with #{self.inspect} failed"
+          end
+
+      end
+
+      # Extend ActiveRecord::Base so it can have the initializer
+      ActiveRecord::Base.extend Enum::Base
+
+      # Create the methods related to the attribute to handle the enum type
+      TypeMap.register_type Adapter::OID::Enum do |subtype, attribute, initial = false, options = nil|
+        return if initial && !Torque::PostgreSQL.config.enum.initializer
+        options = {} if options.nil?
+
+        # Generate methods on self class
+        builder = Builder::Enum.new(self, attribute, subtype, initial, options)
+        return if builder.conflicting?
+        builder.build
+
+        # Mark the enum as defined
+        defined_enums[attribute] = subtype.klass
+      end
+    end
+  end
+end

data/lib/torque/postgresql/attributes/lazy.rb

@@ -0,0 +1,33 @@
+module Torque
+  module PostgreSQL
+    module Attributes
+      class Lazy < BasicObject
+
+        def initialize(klass, *values)
+          @klass, @values = klass, values
+        end
+
+        def ==(other)
+          other.nil?
+        end
+
+        def nil?
+          true
+        end
+
+        def inspect
+          'nil'
+        end
+
+        def __class__
+          Lazy
+        end
+
+        def method_missing(name, *args, &block)
+          @klass.new(*@values).send(name, *args, &block)
+        end
+
+      end
+    end
+  end
+end