edgeway 0.1.0

data/lib/edgeway/model/persistence.rb

@@ -0,0 +1,154 @@
+module Edgeway
+  module Model
+    # A has_many: the association's name, its foreign key and primary key (nil
+    # for the defaults) and its dependent mode (nil, "destroy" or "delete_all").
+    class HasMany
+      attr_reader :name, :foreign_key, :primary_key, :mode
+
+      def initialize(name, foreign_key, primary_key, mode)
+        @name = name
+        @foreign_key = foreign_key
+        @primary_key = primary_key
+        @mode = mode
+      end
+    end
+
+    # A belongs_to: the association's name, our foreign key column and the
+    # parent's primary key column.
+    class BelongsTo
+      attr_reader :name, :foreign_key, :primary_key
+
+      def initialize(name, foreign_key, primary_key)
+        @name = name
+        @foreign_key = foreign_key
+        @primary_key = primary_key
+      end
+    end
+
+    module Persistence
+      def save
+        return false unless valid?
+        touch(!@persisted)
+        if @persisted
+          update_row
+        else
+          insert_row
+        end
+        true
+      end
+
+      def save!
+        raise RecordInvalid.new(@errors) unless save
+        true
+      end
+
+      def update(attrs)
+        assign(attrs)
+        save
+      end
+
+      def update!(attrs)
+        assign(attrs)
+        save!
+      end
+
+      def destroy
+        if self.class.dependents.empty?
+          delete_row
+        else
+          Model.batch do
+            self.class.dependents.each do |d|
+              if d.mode == "destroy"
+                association(d.name).destroy_all
+              else
+                association(d.name).delete_all
+              end
+            end
+            delete_row
+          end
+        end
+        @persisted = false
+        true
+      end
+
+      # eager_load keeps what it loaded here: association and parent_of answer
+      # from it without a query.
+      def cache_children(name, relation)
+        @loaded_children[name] = relation
+      end
+
+      def cache_parent(name, record)
+        @loaded_parents[name] = record
+      end
+
+      def association(name)
+        return @loaded_children[name] if @loaded_children.key?(name)
+        cfg = nil
+        self.class.has_manys.each { |h| cfg = h if h.name == name }
+        raise ArgumentError, "no has_many #{name}" if cfg.nil?
+        # .dup: since matz/spinel 44119ab30 (Strings shared by reference),
+        # Spinel refuses this String as it is, or emits C that doesn't compile.
+        fk = cfg.foreign_key.nil? ? "#{Edgeway::Model.underscore(self.class.name.split("::").last)}_id" : cfg.foreign_key.dup
+        pk = self.class.column(cfg.primary_key.nil? ? "id" : cfg.primary_key.dup)
+        Edgeway::Model::Base.model_named(name, self.class.name).where(fk => @attributes[pk])
+      end
+
+      def parent_of(name)
+        return @loaded_parents[name] if @loaded_parents.key?(name)
+        cfg = nil
+        self.class.belongs_to_list.each { |b| cfg = b if b.name == name }
+        raise ArgumentError, "no belongs_to #{name}" if cfg.nil?
+        parent = Edgeway::Model::Base.model_named(name, self.class.name)
+        key = @attributes[cfg.foreign_key]
+        return parent.find(key) if cfg.primary_key == "id"
+        found = key.nil? ? nil : parent.find_by(cfg.primary_key => key)
+        raise RecordNotFound, "#{parent.table_name} #{cfg.primary_key} #{key} not found" if found.nil?
+        found
+      end
+
+      private
+
+      def delete_row
+        conn = Model.connection
+        Model.write("DELETE FROM #{self.class.table_name} WHERE id = #{conn.placeholder(1)}", [id])
+      end
+
+      def update_row
+        conn = Model.connection
+        cols = self.class.attribute_types.keys
+        values = cols.map { |c| Model.to_db(@attributes[c]) }
+        sets = cols.each_with_index.map { |c, i| "#{c} = #{conn.placeholder(i + 1)}" }.join(", ")
+        Model.write("UPDATE #{self.class.table_name} SET #{sets} WHERE id = #{conn.placeholder(cols.size + 1)}",
+                     values + [id])
+      end
+
+      def insert_row
+        raise ArgumentError, "create isn't supported inside Model.batch" if Model.batching?
+        conn = Model.connection
+        table = self.class.table_name
+        cols = self.class.attribute_types.keys.reject { |c| @attributes[c].nil? }
+        values = cols.map { |c| Model.to_db(@attributes[c]) }
+        sql = "INSERT INTO #{table}"
+        if cols.empty?
+          sql += " DEFAULT VALUES"
+        else
+          marks = cols.each_with_index.map { |_c, i| conn.placeholder(i + 1) }
+          sql += " (#{cols.join(", ")}) VALUES (#{marks.join(", ")})"
+        end
+        if conn.supports_returning?
+          load_row(conn.insert_returning(sql + " RETURNING #{self.class.columns.join(", ")}", values))
+        else
+          new_id = conn.execute(sql, values)["last_insert_id"]
+          load_row(conn.select_all("SELECT #{self.class.columns.join(", ")} FROM #{table} WHERE id = #{conn.placeholder(1)}", [new_id])[0])
+        end
+      end
+
+      def touch(creating)
+        types = self.class.attribute_types
+        now = Model.now
+        write_attribute("created_at", now) if creating && types.key?("created_at")
+        write_attribute("updated_at", now) if types.key?("updated_at")
+      end
+    end
+  end
+end

data/lib/edgeway/model/relation.rb

@@ -0,0 +1,295 @@
+module Edgeway
+  module Model
+    class Relation
+      # eager is the associations eager_load names (empty: none); records, when
+      # set, are what to_a answers instead of a query (an eager-loaded has_many).
+      attr_writer :records
+
+      def initialize(model, where_cols = [], binds = [], order = [], limit = nil, offset = nil, eager = [])
+        @model = model
+        @where_cols = where_cols
+        @binds = binds
+        @order = order
+        @limit = limit
+        @offset = offset
+        @eager = eager
+        @records = nil
+      end
+
+      def where(conditions)
+        cols = @where_cols.dup
+        binds = @binds.dup
+        conditions.each do |k, v|
+          col = @model.column(k)
+          casted = Model.cast(@model.type_of(col), v)
+          # An integer outside 32 bits can't be held as one; it goes as its
+          # text, which SQLite compares as the number it is, so nothing
+          # matches (a find on it is a 404).
+          casted = v.to_s if casted.nil? && !v.nil?
+          cols << col
+          binds << Model.to_db(casted)
+        end
+        Relation.new(@model, cols, binds, @order, @limit, @offset, @eager)
+      end
+
+      def order(col, dir = :asc)
+        Relation.new(@model, @where_cols, @binds, @order + [order_term(col, dir)], @limit, @offset, @eager)
+      end
+
+      # Replaces all the terms.
+      def reorder(col, dir = :asc)
+        Relation.new(@model, @where_cols, @binds, [order_term(col, dir)], @limit, @offset, @eager)
+      end
+
+      def limit(n)
+        Relation.new(@model, @where_cols, @binds, @order, count_arg("limit", n), @offset, @eager)
+      end
+
+      def offset(n)
+        Relation.new(@model, @where_cols, @binds, @order, @limit, count_arg("offset", n), @eager)
+      end
+
+      # Loads the has_manys and belongs_tos named of every record with the one
+      # query: a LEFT JOIN each, always (no separate preload query). The
+      # records' associations then answer from memory. Calls accumulate.
+      #
+      #   Todo.eager_load(:comments, :tags).to_a.each { |t| t.comments.to_a }
+      def eager_load(*names)
+        eager = @eager.dup
+        names.each do |n|
+          eager << n.to_s unless eager.include?(n.to_s)
+        end
+        Relation.new(@model, @where_cols, @binds, @order, @limit, @offset, eager)
+      end
+
+      # Same conditions, but to_a answers these records.
+      def loaded(records)
+        relation = Relation.new(@model, @where_cols, @binds, @order, @limit, @offset)
+        relation.records = records
+        relation
+      end
+
+      def to_a
+        return @records unless @records.nil?
+        return eager_records unless @eager.empty?
+        sql, binds = select(@model.columns.join(", "), true)
+        Model.connection.select_all(sql, binds).map { |row| @model.instantiate(row) }
+      end
+
+      def count
+        sql, binds = select("1", false)
+        Model.connection.select_all("SELECT COUNT(*) AS n FROM (#{sql})", binds)[0]["n"].to_i
+      end
+
+      def exists? = limit(1).count > 0
+
+      def pluck(col)
+        name = @model.column(col)
+        type = @model.type_of(name)
+        sql, binds = select(name, true)
+        Model.connection.select_all(sql, binds).map { |row| Model.cast(type, row[name]) }
+      end
+
+      def first = (@order.empty? ? order(:id) : self).limit(1).to_a.first
+
+      def delete_all
+        raise ArgumentError, "delete_all doesn't support limit/offset" if @limit || @offset
+        conn = Model.connection
+        where_sql, _marks = where_clause(conn)
+        Model.write("DELETE FROM #{@model.table_name}#{where_sql}", @binds.compact)["changes"]
+      end
+
+      def destroy_all
+        records = to_a
+        records.each { |r| r.destroy }
+        records
+      end
+
+      def each(&block) = to_a.each(&block)
+      def map(&block) = to_a.map(&block)
+      def size = to_a.size
+      def empty? = !exists?
+
+      def find_by(conditions) = Relation.new(@model, @where_cols, @binds, @order, @limit, nil, @eager).where(conditions).limit(1).to_a.first
+
+      def find(id)
+        find_by("id" => id) || raise(RecordNotFound, "#{@model.table_name} #{id} not found")
+      end
+
+      def build(attrs = {})
+        record = @model.new(attrs)
+        @where_cols.each_with_index { |col, i| record.write_attribute(col, @binds[i]) }
+        record
+      end
+
+      def create(attrs = {})
+        record = build(attrs)
+        record.save
+        record
+      end
+
+      def create!(attrs = {})
+        record = build(attrs)
+        record.save!
+        record
+      end
+
+      def find_or_create_by(conditions) = find_or_create(conditions, false)
+      def find_or_create_by!(conditions) = find_or_create(conditions, true)
+
+      private
+
+      # The records with @eager loaded. The conditions, order and limit apply
+      # to our own records, so they run in a subquery that each association's
+      # table is joined to. A row is one of ours with one of each association's
+      # (nil without any); joining several has_manys repeats a child once per
+      # row of the others, so a record of ours comes once however many rows it
+      # has, and each child once per record (by id).
+      def eager_records
+        mine = @model.table_name
+        many_flags = []
+        joins = []
+        cols = @model.columns.map { |c| "#{mine}.#{c} AS p_#{c}" }
+        order = @order.empty? ? ["#{mine}.id"] : @order.map { |t| "#{mine}.#{t}" }
+        @eager.each_with_index do |name, i|
+          many_flags << eager_many?(name)
+          other = Edgeway::Model::Base.model_named(name, @model.name)
+          theirs = "eager_#{name}"
+          joins << " LEFT JOIN #{other.table_name} AS #{theirs} ON #{eager_on(name, other, theirs)}"
+          cols = cols + other.columns.map { |c| "#{theirs}.#{c} AS c#{i}_#{c}" }
+          order << "#{theirs}.id"
+        end
+        inner, binds = select(@model.columns.join(", "), true)
+        sql = "SELECT #{cols.join(", ")} FROM (#{inner}) AS #{mine}#{joins.join}"
+        sql += " ORDER BY #{order.join(", ")}"
+
+        records = []
+        # children[i][j]: the records of association j of record i
+        children = []
+        position = {}
+        seen = {}
+        Model.connection.select_all(sql, binds).each do |row|
+          id = row["p_id"]
+          i = position[id]
+          if i.nil?
+            i = records.size
+            position[id] = i
+            mine_row = {}
+            @model.columns.each { |c| mine_row[c] = row["p_" + c] }
+            records << @model.instantiate(mine_row)
+            lists = []
+            @eager.each { |_n| lists << [] }
+            children << lists
+          end
+          @eager.each_with_index do |name, j|
+            cid = row["c#{j}_id"]
+            next if cid.nil?
+            key = "#{j}:#{id}:#{cid}"
+            next if seen.key?(key)
+            seen[key] = true
+            other = Edgeway::Model::Base.model_named(name, @model.name)
+            their_row = {}
+            other.columns.each { |c| their_row[c] = row["c#{j}_" + c] }
+            children[i][j] << other.instantiate(their_row)
+          end
+        end
+        records.each_with_index do |record, i|
+          @eager.each_with_index do |name, j|
+            if many_flags[j]
+              record.cache_children(name, record.association(name).loaded(children[i][j]))
+            else
+              record.cache_parent(name, children[i][j][0]) unless children[i][j].empty?
+            end
+          end
+        end
+        records
+      end
+
+      def eager_many?(name)
+        many = nil
+        @model.has_manys.each { |h| many = h if h.name == name }
+        one = nil
+        @model.belongs_to_list.each { |b| one = b if b.name == name }
+        raise ArgumentError, "no association #{name}" if many.nil? && one.nil?
+        !many.nil?
+      end
+
+      # The join condition of the association `name` (the model `other`,
+      # joined as `theirs`) to our records.
+      def eager_on(name, other, theirs)
+        mine = @model.table_name
+        many = nil
+        @model.has_manys.each { |h| many = h if h.name == name }
+        if many.nil?
+          one = nil
+          @model.belongs_to_list.each { |b| one = b if b.name == name }
+          # .dup: since matz/spinel 44119ab30 (Strings shared by reference),
+          # Spinel refuses this String as it is, or emits C that doesn't compile.
+          return "#{theirs}.#{other.column(one.primary_key.dup)} = #{mine}.#{@model.column(one.foreign_key.dup)}"
+        end
+        fk = many.foreign_key.nil? ? "#{Model.underscore(@model.name.split("::").last)}_id" : many.foreign_key
+        pk = many.primary_key.nil? ? "id" : many.primary_key
+        "#{theirs}.#{other.column(fk)} = #{mine}.#{@model.column(pk)}"
+      end
+
+      def find_or_create(conditions, bang)
+        found = find_by(conditions)
+        return found unless found.nil?
+        begin
+          bang ? create!(conditions) : create(conditions)
+        rescue Edgeway::RecordNotUnique => e
+          again = find_by(conditions)
+          raise e if again.nil?
+          again
+        end
+      end
+
+      def count_arg(what, n)
+        i = Model.to_int(n)
+        raise BadRequest, "bad #{what}: #{n}" if i.nil? || i < 0
+        i
+      end
+
+      def order_term(col, dir)
+        d = dir.to_s.downcase
+        raise BadRequest, "bad order direction: #{dir}" unless d == "asc" || d == "desc"
+        "#{@model.column(col)} #{d.upcase}"
+      end
+
+      # " WHERE ..." (empty without conditions) and the number of placeholders
+      # it used. A nil value is IS NULL, with no bind.
+      def where_clause(conn)
+        marks = 0
+        return ["", marks] if @where_cols.empty?
+        conds = @where_cols.each_with_index.map do |c, i|
+          if @binds[i].nil?
+            "#{c} IS NULL"
+          else
+            marks += 1
+            "#{c} = #{conn.placeholder(marks)}"
+          end
+        end
+        [" WHERE " + conds.join(" AND "), marks]
+      end
+
+      def select(what, ordered)
+        conn = Model.connection
+        where_sql, _marks = where_clause(conn)
+        sql = "SELECT #{what} FROM #{@model.table_name}#{where_sql}"
+        sql += " ORDER BY #{@order.join(", ")}" if ordered && !@order.empty?
+        binds = @binds.compact
+        if @limit
+          binds = binds + [@limit]
+          sql += " LIMIT #{conn.placeholder(binds.size)}"
+        elsif @offset
+          sql += " LIMIT -1"
+        end
+        if @offset
+          binds = binds + [@offset]
+          sql += " OFFSET #{conn.placeholder(binds.size)}"
+        end
+        [sql, binds]
+      end
+    end
+  end
+end

data/lib/edgeway/model/validations.rb

@@ -0,0 +1,136 @@
+module Edgeway
+  module Model
+    module Validations
+      def errors = @errors
+
+      def valid?
+        @errors = []
+        @raw.each do |col, raw|
+          @errors << "#{col} is out of range" if !raw.nil? && @attributes[col].nil?
+        end
+
+        self.class.rules.each do |rule|
+          col = rule.column
+          value = rule.kind == "numericality" && @raw.key?(col) ? @raw[col] : @attributes[col]
+          msg = rule.message(value)
+          @errors << msg unless msg.nil?
+        end
+
+        if @errors.empty?
+          self.class.belongs_to_list.each do |b|
+            fk = @attributes[b.foreign_key]
+            @errors << "#{b.name} must exist" if fk.nil? || Base.model_named(b.name, self.class.name).find_by(b.primary_key => fk).nil?
+          end
+        end
+
+        if @errors.empty?
+          self.class.rules.each do |rule|
+            next unless rule.kind == "uniqueness"
+            @errors << "#{rule.column} has already been taken" if taken?(rule)
+          end
+        end
+        @errors.empty?
+      end
+
+      private
+
+      def taken?(rule)
+        value = @attributes[rule.column]
+        return false if value.nil?
+        found = self.class.where(rule.column => value)
+        rule.scope.each { |c| found = found.where(c => @attributes[self.class.column(c)]) }
+        other = found.limit(1).to_a.first
+        !other.nil? && (new_record? || other.id != id)
+      end
+    end
+
+    class Rule
+      attr_reader :column, :kind
+
+      def self.scope_columns(options)
+        return [] if options == true
+        scope = options[:scope]
+        return [] if scope.nil?
+        scope.is_a?(Array) ? scope.map(&:to_s) : [scope.to_s]
+      end
+
+      def self.bounds(options)
+        h = {}
+        return h if options == true
+        options.each do |k, v|
+          key = k.to_s
+          if key == "in"
+            h["minimum"] = v.min
+            h["maximum"] = v.max
+          else
+            h[key] = v == true ? 1 : v
+          end
+        end
+        h
+      end
+
+      def initialize(attribute, kind, bounds, list, pattern)
+        @column = attribute
+        @kind = kind
+        @bounds = bounds
+        @list = list
+        @pattern = pattern
+      end
+
+      def message(v)
+        # Uniqueness needs a query: Validations#taken? does it.
+        return nil if @kind == "uniqueness"
+        if @kind == "presence"
+          return "#{@column} can't be blank" if v.nil? || v.to_s.strip.empty?
+          return nil
+        end
+        return nil if v.nil?
+        case @kind
+        when "length" then length_message(v.to_s.length)
+        when "inclusion" then @list.include?(v.to_s) ? nil : "#{@column} is not included in the list"
+        when "format" then @pattern.match?(v.to_s) ? nil : "#{@column} is invalid"
+        when "numericality" then numericality_message(v)
+        end
+      end
+
+      def scope = @list
+
+      private
+
+      def length_message(n)
+        if @bounds.key?("minimum") && n < @bounds["minimum"]
+          return "#{@column} is too short (minimum is #{@bounds["minimum"]} characters)"
+        end
+        if @bounds.key?("maximum") && n > @bounds["maximum"]
+          return "#{@column} is too long (maximum is #{@bounds["maximum"]} characters)"
+        end
+        if @bounds.key?("is") && n != @bounds["is"]
+          return "#{@column} is the wrong length (should be #{@bounds["is"]} characters)"
+        end
+        nil
+      end
+
+      def numericality_message(v)
+        text = v.to_s
+        integer = text.match?(/\A[+-]?\d+\z/)
+        # Decimals and exponents too: Float#to_s writes 1.0e+20 and 1.0e-05.
+        return "#{@column} is not a number" unless integer || text.match?(/\A[+-]?\d+(\.\d+)?([eE][+-]?\d+)?\z/)
+        return "#{@column} must be an integer" if @bounds.key?("only_integer") && !integer
+        n = text.to_f
+        if @bounds.key?("greater_than") && !(n > @bounds["greater_than"])
+          return "#{@column} must be greater than #{@bounds["greater_than"]}"
+        end
+        if @bounds.key?("greater_than_or_equal_to") && !(n >= @bounds["greater_than_or_equal_to"])
+          return "#{@column} must be greater than or equal to #{@bounds["greater_than_or_equal_to"]}"
+        end
+        if @bounds.key?("less_than") && !(n < @bounds["less_than"])
+          return "#{@column} must be less than #{@bounds["less_than"]}"
+        end
+        if @bounds.key?("less_than_or_equal_to") && !(n <= @bounds["less_than_or_equal_to"])
+          return "#{@column} must be less than or equal to #{@bounds["less_than_or_equal_to"]}"
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/edgeway/routing/mapper.rb

@@ -0,0 +1,57 @@
+module Edgeway
+  module Routing
+    class Mapper
+      ACTIONS = ["index", "show", "create", "update", "destroy"]
+
+      def initialize(routes, path_prefix, module_prefix)
+        @routes = routes
+        @path_prefix = path_prefix
+        @module_prefix = module_prefix
+      end
+
+      def get(path, to:) = add("GET", path, to)
+      def post(path, to:) = add("POST", path, to)
+      def patch(path, to:) = add("PATCH", path, to)
+      def put(path, to:) = add("PUT", path, to)
+      def delete(path, to:) = add("DELETE", path, to)
+
+      def root(to:) = add("GET", "/", to)
+
+      def namespace(name)
+        yield Mapper.new(@routes, "#{@path_prefix}/#{name}", "#{@module_prefix}#{name}/")
+      end
+
+      def resources(name, only: [], except: [])
+        base = "/#{name}"
+        member = "#{base}/:id"
+        (only + except).each do |a|
+          raise ArgumentError, "unknown action for resources :#{name}: #{a}" unless ACTIONS.include?(a.to_s)
+        end
+        want = ACTIONS.dup
+        want = only.map(&:to_s) unless only.empty?
+        want = want.reject { |a| except.map(&:to_s).include?(a) }
+
+        add("GET", base, "#{name}#index") if want.include?("index")
+        add("POST", base, "#{name}#create") if want.include?("create")
+        add("GET", member, "#{name}#show") if want.include?("show")
+        if want.include?("update")
+          add("PATCH", member, "#{name}#update")
+          add("PUT", member, "#{name}#update")
+        end
+        add("DELETE", member, "#{name}#destroy") if want.include?("destroy")
+        if block_given?
+          yield Mapper.new(@routes, "#{@path_prefix}#{base}/:#{Mapper.singular(name)}_id", @module_prefix)
+        end
+      end
+
+      def self.singular(name) = Inflector.singularize(name)
+
+      private
+
+      def add(verb, path, to)
+        controller, action = to.split("#", 2)
+        @routes.add(Route.new(verb, @path_prefix + path, @module_prefix + controller, action))
+      end
+    end
+  end
+end

data/lib/edgeway/routing/route.rb

@@ -0,0 +1,39 @@
+module Edgeway
+  module Routing
+    class Route
+      attr_reader :verb, :pattern, :controller_path, :action
+
+      def initialize(verb, pattern, controller_path, action)
+        @verb = verb
+        @pattern = pattern
+        @segments = Route.split(pattern)
+        @controller_path = controller_path
+        @action = action
+      end
+
+      def self.split(path) = path.split("/").reject(&:empty?)
+
+      def controller_class_name
+        parts = @controller_path.split("/").map do |part|
+          part.split("_").map(&:capitalize).join
+        end
+        parts.join("::") + "Controller"
+      end
+
+      def match(verb, path)
+        return nil unless verb == @verb || (verb == "HEAD" && @verb == "GET")
+        parts = Route.split(path)
+        return nil unless parts.size == @segments.size
+        found = {}
+        @segments.each_with_index do |seg, i|
+          if seg.start_with?(":")
+            found[seg[1..]] = parts[i]
+          elsif seg != parts[i]
+            return nil
+          end
+        end
+        found
+      end
+    end
+  end
+end