baza_models 0.0.0 → 0.0.1

data/lib/baza_models/model/scopes.rb

@@ -0,0 +1,19 @@
+module BazaModels::Model::Scopes
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def scope(name, blk)
+      @scopes ||= {}
+      name = name.to_sym
+
+      raise "Such a scope already exists" if @scopes.key?(name)
+      @scopes[name] = true
+
+      (class << self; self; end).__send__(:define_method, name) do
+        blk.call
+      end
+    end
+  end
+end

data/lib/baza_models/model/translation_functionality.rb

@@ -0,0 +1,30 @@
+module BazaModels::Model::TranslationFunctionality
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def human_attribute_name(attribute_name)
+      class_name = StringCases.camel_to_snake(name)
+
+      keys = [
+        "baza_models.attributes.#{class_name}.#{attribute_name}",
+        "activerecord.attributes.#{class_name}.#{attribute_name}"
+      ]
+
+      keys.each do |key|
+        return I18n.t(key) if I18n.exists?(key)
+      end
+
+      StringCases.snake_to_camel(attribute_name)
+    end
+
+    def model_name
+      BazaModels::ClassTranslation.new(class: self)
+    end
+  end
+
+  def model_name
+    self.class.model_name
+  end
+end

data/lib/baza_models/model/validations.rb

@@ -0,0 +1,95 @@
+module BazaModels::Model::Validations
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  def valid?
+    fire_callbacks(:before_validation)
+
+    if new_record?
+      fire_callbacks(:before_validation_on_create)
+    else
+      fire_callbacks(:before_validation_on_update)
+    end
+
+    reset_errors
+
+    validators = self.class.__validators
+
+    merged_data = @data.merge(@changes)
+    merged_data.each do |attribute_name, attribute_value|
+      next unless validators.key?(attribute_name)
+
+      validators[attribute_name].each do |validator|
+        next unless validator.fire?(self)
+        validator.validate(self, attribute_value)
+      end
+    end
+
+    execute_custom_validations
+    fire_callbacks(:after_validation)
+
+    if new_record?
+      fire_callbacks(:after_validation_on_create)
+    else
+      fire_callbacks(:after_validation_on_update)
+    end
+
+    @errors.empty?
+  end
+
+  module ClassMethods
+    def validates(*attribute_names, args)
+      special_args = {
+        if: args.delete(:if)
+      }
+
+      attribute_names.each do |attribute_name|
+        args.each do |validator_name, _validator_args|
+          validator_camel_name = StringCases.snake_to_camel(validator_name)
+          class_name = "#{validator_camel_name}Validator"
+
+          __validators[attribute_name] ||= []
+          __validators[attribute_name] << BazaModels::Validators.const_get(class_name).new(attribute_name, args.merge(special_args))
+        end
+      end
+    end
+
+    def validates_confirmation_of(*args)
+      validate_shortcut(:confirmation, args)
+    end
+
+    def validates_format_of(*args)
+      validate_shortcut(:format, args)
+    end
+
+    def validates_length_of(*args)
+      validate_shortcut(:length, args)
+    end
+
+    def validates_presence_of(*args)
+      validate_shortcut(:presence, args)
+    end
+
+    def validates_uniqueness_of(*args)
+      validate_shortcut(:uniqueness, args)
+    end
+
+    def validate_shortcut(type, args)
+      if args.last.is_a?(Hash)
+        before_opts = args.pop
+
+        opts = {type => before_opts}
+        opts[:if] = before_opts.delete(:if) if before_opts.key?(:if)
+      else
+        opts = {type => true}
+      end
+
+      validates(*args, opts)
+    end
+
+    def __validators
+      @validators ||= {}
+    end
+  end
+end

data/lib/baza_models/query.rb

@@ -0,0 +1,447 @@
+require "array_enumerator"
+
+class BazaModels::Query
+  path = "#{File.dirname(__FILE__)}/query"
+
+  autoload :Inspector, "#{path}/inspector"
+  autoload :Not, "#{path}/not"
+
+  attr_accessor :_previous_model, :_relation
+
+  def initialize(args)
+    @args = args
+    @model = @args[:model]
+    @db = @model.db
+
+    raise "No database?" unless @db
+
+    @selects = args[:selects] || []
+    @wheres = args[:wheres] || []
+    @includes = args[:includes] || []
+    @joins = args[:joins] || []
+    @groups = args[:groups] || []
+    @orders = args[:orders] || []
+    @limit = args[:limit]
+
+    @joins_tracker = {}
+  end
+
+  def all
+    self
+  end
+
+  def any?
+    if @db.query(clone.select(:id).limit(1).to_sql).fetch
+      return true
+    else
+      return false
+    end
+  end
+
+  def empty?
+    !any?
+  end
+
+  def none?
+    !any?
+  end
+
+  def count
+    if @_previous_model && @_previous_model.new_record?
+      return autoloaded_cache_or_create.length
+    else
+      query = clone
+
+      query.instance_variable_set(:@selects, [])
+      query = clone.select("COUNT(*) AS count")
+
+      @db.query(query.to_sql).fetch.fetch(:count)
+    end
+  end
+
+  def length
+    count
+  end
+
+  def find(id)
+    clone.where(id: id).limit(1).to_enum.first
+  end
+
+  def first
+    return autoloaded_cache.first if should_use_autoload?
+
+    query = clone.limit(1)
+
+    orders = query.instance_variable_get(:@orders)
+    query = query.order(:id) if orders.empty?
+
+    query.to_enum.first
+  end
+
+  def last
+    return autoloaded_cache.last if should_use_autoload?
+
+    query = clone.limit(1)
+
+    orders = query.instance_variable_get(:@orders)
+    query = query.order(:id) if orders.empty?
+
+    query.reverse_order.to_enum.first
+  end
+
+  def select(select)
+    if select.is_a?(Symbol)
+      @selects << "`#{@model.table_name}`.`#{select}`"
+    else
+      @selects << select
+    end
+
+    self
+  end
+
+  def offset(offset)
+    @offset = offset
+    self
+  end
+
+  def limit(limit)
+    @limit = limit
+    self
+  end
+
+  def includes(name)
+    @includes << name
+    self
+  end
+
+  def where(args = nil)
+    if args.is_a?(String)
+      @wheres << "(#{args})"
+    elsif args.is_a?(Array)
+      str = args.shift
+
+      args.each do |arg|
+        if arg.is_a?(Symbol)
+          arg = "`#{@model.table_name}`.`#{@db.escape_column(arg)}`"
+        elsif arg.is_a?(FalseClass)
+          arg = "0"
+        elsif arg.is_a?(TrueClass)
+          arg = "1"
+        else
+          arg = "'#{@db.esc(arg)}'"
+        end
+
+        str.sub!("?", arg)
+      end
+
+      @wheres << "(#{str})"
+    elsif args == nil
+      return Not.new(query: self)
+    else
+      args.each do |key, value|
+        if value.is_a?(Hash)
+          value.each do |hash_key, hash_value|
+            @wheres << "`#{key}`.`#{hash_key}` = '#{@db.esc(hash_value)}'"
+          end
+        else
+          @wheres << "`#{@model.table_name}`.`#{key}` = '#{@db.esc(value)}'"
+        end
+      end
+    end
+
+    self
+  end
+
+  def joins(*arguments)
+    BazaModels::Query::Inspector.new(
+      query: self,
+      model: @model,
+      argument: arguments,
+      joins: @joins,
+      joins_tracker: @joins_tracker
+    ).execute
+
+    self
+  end
+
+  def group(name)
+    if name.is_a?(Symbol)
+      @groups << "`#{@model.table_name}`.`#{name}`"
+    elsif name.is_a?(String)
+      @groups << name
+    else
+      raise "Didn't know how to group by that argument: #{name}"
+    end
+
+    self
+  end
+
+  def order(name)
+    if name.is_a?(Symbol)
+      @orders << "`#{@model.table_name}`.`#{name}`"
+    elsif name.is_a?(String)
+      @orders << name
+    else
+      raise "Didn't know how to order by that argument: #{name}"
+    end
+
+    self
+  end
+
+  def reverse_order
+    @reverse_order = true
+    self
+  end
+
+  def to_enum
+    return autoloaded_cache if should_use_autoload?
+
+    array_enum = ArrayEnumerator.new do |yielder|
+      @db.query(to_sql).each do |data|
+        yielder << @model.new(data, init: true)
+      end
+    end
+
+    if @includes.empty?
+      return array_enum
+    else
+      array = array_enum.to_a
+
+      if @includes.any? && array.any?
+        autoloader = BazaModels::Autoloader.new(
+          models: array,
+          autoloads: @includes,
+          db: @db
+        )
+        autoloader.autoload
+      end
+
+      return array
+    end
+  end
+
+  def each
+    to_enum.each do |model|
+      yield model
+    end
+  end
+
+  def find_each
+    query = clone
+    query.instance_variable_set(:@order, [])
+    query.instance_variable_set(:@limit, nil)
+    query = query.order(:id)
+
+    offset = 0
+
+    loop do
+      query = query.offset(offset, 1000)
+      offset += 1000
+
+      count = 0
+      query.each do |model|
+        yield model
+        count += 1
+      end
+
+      break if count == 0
+    end
+  end
+
+  def find_first(args)
+    where(args).first
+  end
+
+  def to_a
+    to_enum.to_a
+  end
+
+  def to_sql
+    sql = "SELECT "
+
+    if @selects.empty?
+      sql << "`#{@model.table_name}`.*"
+    else
+      sql << @selects.join(", ")
+    end
+
+    sql << " FROM `#{@model.table_name}`"
+
+    unless @joins.empty?
+      @joins.each do |join|
+        sql << " #{join}"
+      end
+    end
+
+    unless @wheres.empty?
+      sql << " WHERE "
+
+      first = true
+      @wheres.each do |where|
+        if first == true
+          first = false
+        else
+          sql << " AND "
+        end
+
+        sql << where
+      end
+    end
+
+    unless @groups.empty?
+      sql << " GROUP BY "
+
+      first = true
+      @groups.each do |group|
+        if first
+          first = false
+        else
+          sql << ", "
+        end
+
+        sql << group
+      end
+    end
+
+    unless @orders.empty?
+      sql << " ORDER BY "
+
+      first = true
+      @orders.each do |order|
+        if first
+          first = false
+        else
+          sql << ", "
+        end
+
+        if @reverse_order
+          if order.match(/\s+desc/i)
+            order = order.gsub(/\s+desc/i, " ASC")
+          elsif order.match(/\s+asc/i)
+            order = order.gsub(/\s+asc/i, " DESC")
+          else
+            order = "#{order} DESC"
+          end
+        end
+
+        sql << order
+      end
+    end
+
+    if @limit && @offset
+      sql << " LIMIT #{@offset.to_i}, #{@limit.to_i}"
+    elsif @limit
+      sql << " LIMIT #{@limit.to_i}"
+    end
+
+    sql.strip
+  end
+
+  def destroy_all
+    each(&:destroy!)
+  end
+
+  def to_s
+    "#<BazaModels::Query class=#{@model.name} wheres=#{@wheres}>"
+  end
+
+  def inspect
+    to_s
+  end
+
+  def <<(model)
+    raise "No previous model set" unless @_previous_model
+    raise "No relation" unless @_relation
+
+    if model.persisted?
+      model.update_attributes!(@_relation.fetch(:foreign_key) => @_previous_model.id)
+    else
+      autoloaded_cache_or_create << model
+    end
+
+    self
+  end
+
+  # CanCan supports
+  def accessible_by(ability, action = :index)
+    ability.model_adapter(self, action).database_records
+  end
+
+  def <=(_other)
+    false
+  end
+
+  def sanitize_sql(value)
+    return value if value.is_a?(Array) || value.is_a?(Integer) || value.is_a?(Integer)
+    "'#{@db.esc(value)}'"
+  end
+
+  def page(some_page)
+    some_page ||= 1
+    offset = (some_page.to_i - 1) * per
+
+    clone.offset(offset).limit(30)
+  end
+
+  def per
+    @per ||= 30
+  end
+
+  def total_pages
+    pages_count = (count.to_f / @per.to_f)
+    pages_count = 1 if pages_count.nan? || pages_count == Float::INFINITY
+    pages_count = pages_count.to_i
+    pages_count = 1 if pages_count == 0
+    pages_count
+  end
+
+private
+
+  def should_use_autoload?
+    !any_mods? && autoloaded_on_previous_model?
+  end
+
+  def autoloaded_cache_or_create
+    @_previous_model.autoloads[@_relation.fetch(:relation_name)] ||= []
+    autoloaded_cache
+  end
+
+  def autoloaded_cache
+    @_previous_model.autoloads.fetch(@_relation.fetch(:relation_name))
+  end
+
+  def any_mods?
+    @groups.any? || @includes.any? || @orders.any? || @joins.any? || any_wheres_other_than_relation?
+  end
+
+  def any_wheres_other_than_relation?
+    if @_previous_model && @_relation && @wheres.length == 1
+      looks_like = "`#{@_relation.fetch(:table_name)}`.`#{@_relation.fetch(:foreign_key)}` = '#{@_previous_model.id}'"
+
+      return false if @wheres.first == looks_like
+    end
+
+    true
+  end
+
+  def autoloaded_on_previous_model?
+    if @_previous_model && @_relation
+      return true if @_previous_model.autoloads.include?(@_relation.fetch(:relation_name))
+    end
+
+    false
+  end
+
+  def clone
+    BazaModels::Query.new(
+      model: @model,
+      selects: @selects.dup,
+      wheres: @wheres.dup,
+      joins: @joins.dup,
+      includes: @includes.dup,
+      groups: @groups.dup,
+      orders: @orders.dup,
+      limit: @limit
+    )
+  end
+end