metamodel 0.2.0 → 0.3.1

data/lib/metamodel/record/association.rb

@@ -7,16 +7,12 @@ module MetaModel
       attr_reader :dependent
       attr_accessor :major_model
       attr_accessor :secondary_model
-      attr_accessor :through
 
       def initialize(name, major_model, secondary_model, relation, args)
-        # through = args[:through]
-        through = nil
         dependent = args[:dependent] || :nullify
 
         @name            = name.to_s.camelize :lower
         @relation        = relation
-        @through         = through.to_s.camelize.singularize unless through.nil?
         @dependent       = dependent
         @major_model     = major_model
         @secondary_model = secondary_model
@@ -24,44 +20,52 @@ module MetaModel
         validate_association
       end
 
+      def class_name
+        "#{major_model.name}#{secondary_model.name}Association".camelize
+      end
+
+      def reverse_class_name
+        "#{secondary_model.name}#{major_model.name}Association".camelize
+      end
+
+      def major_model_id
+        major_model.foreign_id
+      end
+
+      def secondary_model_id
+        secondary_model.foreign_id
+      end
+
+      def hash_value
+        self.hash.to_s(16)
+      end
+
       def expect_constraint?(constraint)
         result = true
         result &= self.major_model == constraint.secondary_model
         result &= self.secondary_model == constraint.major_model
-        result &= self.through == constraint.through
 
         result &= case [self.relation, constraint.relation]
           when [:has_one, :belongs_to], [:belongs_to, :has_one] then true
           when [:belongs_to, :has_many] then
             return false if self.dependent == :destroy
-            return true unless constraint.through
-            return false
+            return true
           when [:has_many, :belongs_to] then
             return false if constraint.dependent == :destroy
-            return true unless self.through
-            return false
+            return true
           when [:has_many, :has_many] then
-            self.through == constraint.through
+            return true
           else false
         end
         result
       end
 
-      def secondary_model_instance
-        case relation
-        when :has_many, :has_one then "#{secondary_model.name}.find(privateId)"
-        when :belongs_to then "#{secondary_model.name}.find(#{secondary_model.foreign_id})"
-        else ""
-        end
-      end
-
       #-------------------------------------------------------------------------#
 
       # @!group Validation
 
       def validate_association
         validate_dependent(@dependent)
-        validate_through(@through)
       end
 
       def validate_dependent(dependent)
@@ -71,12 +75,6 @@ module MetaModel
           unless supported_dependent_options.include? dependent
       end
 
-      def validate_through(through)
-        raise Informative, "belongs_to can't coexist with through." \
-          if !!through && @relation == :belongs_to
-      end
-
-
       #-------------------------------------------------------------------------#
 
       # @!group Relation
@@ -100,11 +98,7 @@ module MetaModel
       end
 
       def debug_description
-        if through
-          "#{major_model.name}.#{relation}.#{secondary_model.name}.through.#{through.name}.#{dependent}"
-        else
-          "#{major_model.name}.#{relation}.#{secondary_model.name}.#{dependent}"
-        end
+        "#{major_model.name}.#{relation}.#{secondary_model.name}.#{dependent}"
       end
     end
   end

data/lib/metamodel/record/model.rb

@@ -15,10 +15,6 @@ module MetaModel
         @properties.select { |prop| prop.name == property }.size > 0
       end
 
-      def all_foreign_properties
-        @properties.select { |element| element.is_foreign? }
-      end
-
       def properties_exclude_id
         properties_exclude_property "id"
       end
@@ -70,19 +66,19 @@ module MetaModel
       def build_table
         table = "CREATE TABLE #{table_name}"
         main_sql = @properties.map do |property|
-          result = "#{property.name} #{property.database_type}"
+          result = "#{property.name.underscore} #{property.database_type}"
           result << " PRIMARY KEY" if property.is_primary?
           result << " UNIQUE" if property.is_unique?
           result << " DEFAULT #{property.default_value}" if property.has_default_value?
           result
         end
-        foreign_sql = @properties.map do |property|
-          next unless property.is_foreign?
-          reference_table_name = property.type.tableize
-          "FOREIGN KEY(#{property.name}) REFERENCES #{reference_table_name}(privateId)"
-        end
+        # foreign_sql = @properties.map do |property|
+        #   next unless property.is_foreign?
+        #   reference_table_name = property.type.tableize
+        #   "FOREIGN KEY(#{property.name}) REFERENCES #{reference_table_name}(privateId)"
+        # end
 
-        table + "(privateId INTEGER PRIMARY KEY, #{(main_sql + foreign_sql).compact.join(", ")});"
+        table + "(private_id INTEGER PRIMARY KEY, #{(main_sql).compact.join(", ")});"
       end
 
       private

data/lib/metamodel/record/property.rb

@@ -73,10 +73,6 @@ module MetaModel
         @modifiers.include? :primary
       end
 
-      def is_foreign?
-        @modifiers[:foreign]
-      end
-
       def is_optional?
         @type.to_s.end_with? "?"
       end

data/lib/metamodel/template/belongs_to_association.swift

@@ -0,0 +1,29 @@
+//
+//  <%= association.class_name %>.swift
+//  MetaModel
+//
+//  Created by MetaModel.
+//  Copyright © 2016 metamodel. All rights reserved.
+//
+
+import Foundation
+
+extension <%= association.class_name %> {
+    static func create(<%= association.major_model_id %> <%= association.major_model_id %>: Int, <%= association.secondary_model_id %>: Int) {
+        executeSQL("INSERT INTO \(<%= association.class_name %>.tableName) (<%= association.major_model_id.underscore %>, <%= association.secondary_model_id.underscore %>) VALUES (\(<%= association.major_model_id %>), \(<%= association.secondary_model_id %>))")
+    }
+}
+
+public extension <%= association.major_model.name %> {
+    var <%= association.name %>: <%= association.secondary_model.name %>? {
+        get {
+            guard let id = <%= association.class_name %>.findBy(<%= association.major_model.foreign_id %>: privateId).first?.commentId else { return nil }
+            return <%= association.secondary_model.name %>.find(id)
+        }
+        set {
+            guard let newValue = newValue else { return }
+            <%= association.class_name %>.findBy(<%= association.major_model_id %>: privateId).forEach { $0.delete() }
+            <%= association.class_name %>.create(<%= association.major_model_id %>: newValue.privateId, <%= association.secondary_model_id %>: privateId)
+        }
+    }
+}

data/lib/metamodel/template/has_many_association.swift

@@ -0,0 +1,99 @@
+//
+//  <%= association.class_name %>.swift
+//  MetaModel
+//
+//  Created by MetaModel.
+//  Copyright © 2016 metamodel. All rights reserved.
+//
+
+import Foundation
+
+typealias <%= association.reverse_class_name %> = <%= association.class_name %>
+
+struct <%= association.class_name %> {
+    var privateId: Int = 0
+    var <%= association.major_model_id %>: Int = 0
+    var <%= association.secondary_model_id %>: Int = 0
+
+    enum Association: String, CustomStringConvertible {
+        case privateId = "private_id"
+        case <%= association.major_model_id %> = "<%= association.major_model_id.underscore %>"
+        case <%= association.secondary_model_id %> = "<%= association.secondary_model_id.underscore %>"
+        var description: String { get { return self.rawValue } }
+    }
+    <% [association.major_model, association.secondary_model].each do |model| %>
+    <%= """static func findBy(#{model.foreign_id} #{model.foreign_id}: Int) -> [#{association.class_name}] {
+        let query = \"SELECT * FROM \\(tableName) WHERE \\(Association.#{model.foreign_id}) = \\(#{model.foreign_id})\"
+
+        var models: [#{association.class_name}] = []
+        guard let stmt = executeSQL(query) else { return models }
+        for values in stmt {
+            let association = #{association.class_name}(values: values)
+            models.append(association)
+        }
+        return models
+    }""" %>
+    <% end %>
+    func delete() {
+        executeSQL("DELETE * FROM \(<%= association.class_name %>.tableName) WHERE \(Association.privateId) = \(privateId)")
+    }
+}
+
+extension <%= association.class_name %> {
+    static func create(<%= association.major_model_id %> <%= association.major_model_id %>: Int, <%= association.secondary_model_id %>: Int) {
+        executeSQL("INSERT INTO \(<%= association.class_name %>.tableName) (<%= association.major_model_id.underscore %>, <%= association.secondary_model_id.underscore %>) VALUES (\(<%= association.major_model_id %>), \(<%= association.secondary_model_id %>))")
+    }
+}
+
+extension <%= association.class_name %> {
+    init(values: Array<Optional<Binding>>) {
+        let privateId: Int64 = values[0] as! Int64
+        let <%= association.major_model_id %>: Int64 = values[1] as! Int64
+        let <%= association.secondary_model_id %>: Int64 = values[2] as! Int64
+
+        self.init(privateId: Int(privateId), <%= association.major_model_id %>: Int(<%= association.major_model_id %>), <%= association.secondary_model_id %>: Int(<%= association.secondary_model_id %>))
+    }
+}
+
+extension <%= association.class_name %> {
+
+    static let tableName = "<%= association.class_name.underscore %>"
+    static func initialize() {
+        let initializeTableSQL = "CREATE TABLE \(tableName)(" +
+          "private_id INTEGER PRIMARY KEY, " +
+          "<%= association.major_model_id.underscore %> INTEGER NOT NULL, " +
+          "<%= association.secondary_model_id.underscore %> INTEGER NOT NULL, " +
+          "FOREIGN KEY(<%= association.major_model_id.underscore %>) REFERENCES <%= association.major_model.table_name %>(private_id)," +
+          "FOREIGN KEY(<%= association.secondary_model_id.underscore %>) REFERENCES <%= association.secondary_model.table_name %>(private_id)" +
+        ");"
+
+        executeSQL(initializeTableSQL)
+    }
+    static func deinitialize() {
+        let dropTableSQL = "DROP TABLE \(tableName)"
+        executeSQL(dropTableSQL)
+    }
+}
+
+public extension <%= association.major_model.name %> {
+    var <%= association.name %>: [<%= association.secondary_model.name %>] {
+        get {
+            let ids = <%= association.class_name %>.findBy(<%= association.major_model_id %>: privateId).map { $0.<%= association.secondary_model_id %> }
+            return <%= association.secondary_model.name %>.find(ids).result
+        }
+        set {
+            <%= association.class_name %>.findBy(<%= association.major_model_id %>: privateId).forEach { $0.delete() }
+            newValue.forEach { <%= association.class_name %>.create(<%= association.major_model_id %>: privateId, <%= association.secondary_model_id %>: $0.privateId) }
+        }
+    }
+
+    func create<%= association.secondary_model.name %>(<%= association.secondary_model.property_key_type_pairs %>) -> <%= association.secondary_model.name %>? {
+        guard let result = <%= association.secondary_model.name %>.create(<%= association.secondary_model.property_key_value_pairs %>) else { return nil }
+        <%= association.class_name %>.create(<%= association.major_model_id %>: privateId, <%= association.secondary_model_id %>: result.privateId)
+        return result
+    }
+
+    func append<%= association.secondary_model.name %>(<%= association.secondary_model.property_key_type_pairs %>) -> <%= association.secondary_model.name %>? {
+        return create<%= association.secondary_model.name %>(<%= association.secondary_model.property_key_value_pairs %>)
+    }
+}

data/lib/metamodel/template/helper.swift

@@ -1,11 +1,9 @@
 // MAKR: - Helper
 
 public class <%= model.relation_name %>: Relation<<%= model.name %>> {
-    <% model.all_foreign_properties.each do |foreign_property| %><%= """var #{foreign_property.name} = 0
-    """%><% end %>
     override init() {
         super.init()
-        self.select = "SELECT \(<%= model.name %>.tableName.unwrapped).* FROM \(<%= model.name %>.tableName.unwrapped)"
+        self.select = "SELECT \(<%= model.name %>.tableName).* FROM \(<%= model.name %>.tableName)"
     }
 
     override var result: [<%= model.name %>] {
@@ -20,7 +18,7 @@ public class <%= model.relation_name %>: Relation<<%= model.name %>> {
     }
 
     func expandColumn(column: <%= model.name %>.Column) -> String {
-        return "\(<%= model.name %>.tableName.unwrapped).\(column.unwrapped)"
+        return "\(<%= model.name %>.tableName).\(column)"
     }
 }
 
@@ -36,7 +34,7 @@ extension <%= model.name %> {
 }
 
 extension <%= model.name %> {
-    var itself: String { get { return "WHERE \(<%= model.name %>.tableName.unwrapped).\("privateId".unwrapped) = \(privateId)" } }
+    var itself: String { get { return "WHERE \(<%= model.name %>.tableName).private_id = \(privateId)" } }
 }
 
 extension <%= model.relation_name %> {
@@ -44,8 +42,12 @@ extension <%= model.relation_name %> {
         return filter(privateId)
     }
 
+    func find(privateIds: [Int]) -> Self {
+        return filter([.privateId: privateIds])
+    }
+
     func filter(privateId: Int) -> Self {
-        self.filter.append("\"privateId\" = \(privateId)")
+        self.filter.append("private_id = \(privateId)")
         return self
     }
 }

data/lib/metamodel/template/metamodel.swift

@@ -27,5 +27,12 @@ public class MetaModel {
             #{model.name}.initialize()
         }""" %>
         <% end %>
+
+        <% associations.each do |association| %><% if association.relation.to_s.start_with? "has" %><%= """if infos[#{association.class_name}.tableName] != \"#{association.hash_value}\" {
+            updateMetaModelTableInfos(#{association.class_name}.tableName, hashValue: \"#{association.hash_value}\")
+            #{association.class_name}.deinitialize()
+            #{association.class_name}.initialize()
+        }""" %>
+        <% end %><% end %>
     }
 }

data/lib/metamodel/template/model_delete.swift

@@ -3,11 +3,8 @@
 public extension <%= model.name %> {
     var delete: Bool {
         get {
-            let deleteSQL = "DELETE FROM \(<%= model.name %>.tableName.unwrapped) \(itself)"
-            executeSQL(deleteSQL)<% model.associations.each do |association| %>
-            <%= association.secondary_model_instance + "?.delete" if association.dependent == :destroy %>
-            <%= association.secondary_model_instance + "?.update(#{model.foreign_id}: 0)" if association.dependent == :nullify && model.contains?(model.foreign_id) %>
-            <% end %>
+            let deleteSQL = "DELETE FROM \(<%= model.name %>.tableName) \(itself)"
+            executeSQL(deleteSQL)
             return true
         }
     }

data/lib/metamodel/template/model_initialize.swift

@@ -4,11 +4,12 @@ public struct <%= model.name %> {
     <% end %>
     static let tableName = "<%= model.table_name %>"
 
-    public enum Column: String, Unwrapped {
-        <% model.properties.each do |property| %><%= """case #{property.name} = \"#{property.name}\"""" %>
+    public enum Column: String, CustomStringConvertible {
+        <% model.properties.each do |property| %><%= """case #{property.name} = \"#{property.name.underscore}\"""" %>
         <% end %>
-        case privateId = "privateId"
-        var unwrapped: String { get { return self.rawValue.unwrapped } }
+        case privateId = "private_id"
+
+        public var description: String { get { return self.rawValue } }
     }
 
     public init(<%= model.property_key_type_pairs false %>) {
@@ -34,7 +35,7 @@ public struct <%= model.name %> {
         <%= """columnsSQL.append(.#{property.name})
         valuesSQL.append(#{property.name})
         """ %><% end %><% end %>
-        let insertSQL = "INSERT INTO \(tableName.unwrapped) (\(columnsSQL.map { $0.rawValue }.joinWithSeparator(", "))) VALUES (\(valuesSQL.map { $0.unwrapped }.joinWithSeparator(", ")))"
+        let insertSQL = "INSERT INTO \(tableName) (\(columnsSQL.map { $0.rawValue }.joinWithSeparator(", "))) VALUES (\(valuesSQL.map { $0.unwrapped }.joinWithSeparator(", ")))"
         guard let _ = executeSQL(insertSQL),
           let lastInsertRowId = executeScalarSQL("SELECT last_insert_rowid();") as? Int64 else { return nil }
         var result = <%= model.name %>(<%= model.property_key_value_pairs %>)
@@ -42,16 +43,3 @@ public struct <%= model.name %> {
         return result
     }
 }
-
-public extension <%= model.relation_name %> {
-    <% model.all_foreign_properties.each do |property| %>
-    func create(<%= model.property_key_type_pairs_without_property property.name %>) -> <%= model.name %>? {
-        return <%= model.name %>.create(<% if model.properties_exclude_property(property).count == 0 %><%= "#{property}: property" %><% else %><%= model.property_key_value_pairs %><% end %>)
-    }
-
-    func append(element: <%= model.name %>) {
-        var element = element
-        element.<%= property.name %> = <%= property.name %>
-    }
-    <% end %>
-}

data/lib/metamodel/template/model_query.swift

@@ -29,6 +29,10 @@ public extension <%= model.name %> {
         return <%= model.relation_name %>().find(id).first
     }
 
+    static func find(ids: [Int]) -> <%= model.relation_name %> {
+        return <%= model.relation_name %>().find(ids)
+    }
+
     static func findBy(<%= model.property_key_type_pairs(true, true) %>) -> <%= model.relation_name %> {
         return <%= model.relation_name %>().findBy(<%= model.property_key_value_pairs %>)
     }
@@ -90,13 +94,13 @@ public extension <%= model.relation_name %> {
             }
 
             if let value = value as? String {
-                filterByEqual(value.unwrapped)
+                filterByEqual(value)
             } else if let value = value as? Int {
                 filterByEqual(value)
             } else if let value = value as? Double {
                 filterByEqual(value)
             } else if let value = value as? [String] {
-                filterByIn(value.map { $0.unwrapped })
+                filterByIn(value.map { $0 })
             } else if let value = value as? [Int] {
                 filterByIn(value.map { $0.description })
             } else if let value = value as? [Double] {
@@ -128,7 +132,7 @@ public extension <%= model.relation_name %> {
     }
 
     func orderBy(column: <%= model.name %>.Column, asc: Bool) -> Self {
-        self.order.append("\(expandColumn(column)) \(asc ? "ASC".unwrapped : "DESC".unwrapped)")
+        self.order.append("\(expandColumn(column)) \(asc ? "ASC" : "DESC")")
         return self
     }
 }

data/lib/metamodel/template/model_update.swift

@@ -13,11 +13,11 @@ public extension <%= model.name %> {
         if let attributes = attributes as? [<%= model.name %>.Column: Unwrapped] {
             for (key, value) in attributes {
                 switch key {
-                <% model.properties_exclude_id.each do |property| %><%= """case .#{property.name}: setSQL.append(\"\\(key.unwrapped) = \\(value.unwrapped)\")""" %>
+                <% model.properties_exclude_id.each do |property| %><%= """case .#{property.name}: setSQL.append(\"\\(key) = \\(value.unwrapped)\")""" %>
                 <% end %>default: break
                 }
             }
-            let updateSQL = "UPDATE \(<%= model.name %>.tableName.unwrapped) SET \(setSQL.joinWithSeparator(", ")) \(itself)"
+            let updateSQL = "UPDATE \(<%= model.name %>.tableName) SET \(setSQL.joinWithSeparator(", ")) \(itself)"
             executeSQL(updateSQL) {
                 for (key, value) in attributes {
                     switch key {