watcher_data 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7b21e6142612ea22dea7f3a69a90948fd924c6ca
+  data.tar.gz: f9f0df762e468d63cc917e037238674062f3964a
+SHA512:
+  metadata.gz: c0bbdb7f28cd587a5562536c8c368451aa40ac2ebfd64ee4ce2a4b25129bdde9c263a5418058458b91864e9d5e002e2895a802b83594430b39ec2e89c00d765d
+  data.tar.gz: 63010dc009605213f9cf8a85103e7d6a916e87d88208b8371c13859551adbaca33c887880895544aab4260ab81930fb0b40976d967ed14d63bacced72446aa81

data/lib/watcher.rb

@@ -0,0 +1,132 @@
+class Watcher
+  attr_accessor :models
+  def initialize(models)
+    self.models = models
+    @association_tables = {}
+  end
+
+  def foreign_keys_for(model)
+    model
+      .reflections
+      .select {|reflection_name, reflection| reflection.macro == :belongs_to && !reflection.options[:polymorphic]}
+      .map { |reflection_name, reflection| reflection.foreign_key }
+  end
+
+  def serialized_column(column_name, column_type, model, foreign_keys)
+    ret = { name: column_name, type: column_type.type }
+
+    ret[:primary_key] = true if column_name == model.primary_key
+    ret[:foreign_key] = true if foreign_keys.include?(column_name)
+    ret
+  end
+
+  def seriaized_association(reflection_name, reflection)
+    foreign_key_on_foreign_table =
+      case
+      when reflection.options[:through]
+        reflection.source_reflection.macro.in? %i{has_many has_one}
+      else
+        reflection.macro.in? %i{has_many has_one}
+      end
+    return [] if reflection.options[:as]
+    ret = {
+      name: reflection_name,
+      joins: reflection.class_name,
+      foreign_table: reflection.table_name,
+      foreign_key: foreign_key_on_foreign_table ? reflection.foreign_key : reflection.association_primary_key,
+      primary_key: foreign_key_on_foreign_table ? reflection.association_primary_key : reflection.foreign_key,
+      type: reflection.macro,
+      through: reflection.options[:through],
+      inverse_of: reflection.inverse_of.try(:name),
+    }
+
+    sec = nil
+
+    if reflection.macro == :has_and_belongs_to_many
+      ret[:through] = reflection.join_table
+      ret[:type] = :has_many
+      ret[:primary_key] = reflection.association_foreign_key
+      sec = {
+        name: reflection.join_table,
+        joins: reflection.join_table.camelize,
+        foreign_table: reflection.join_table,
+        foreign_key: reflection.foreign_key,
+        primary_key: reflection.association_primary_key,
+        type: :has_many
+      }
+    end
+
+    [ret.compact, sec].compact
+  end
+
+  def serialize_habtam_reflection(model, reflection)
+    name = reflection.join_table.camelize
+    @association_tables[name] = {
+      name: name,
+      table_name: reflection.join_table,
+      columns: [
+        {
+          name: reflection.association_foreign_key,
+          type: :integer,
+          foreign_key: true
+        },
+        {
+          name: reflection.foreign_key,
+          type: :integer,
+          foreign_key: true
+        }
+      ],
+      associations: [
+        {
+          name: reflection.class_name.underscore,
+          joins: reflection.class_name,
+          foreign_table: reflection.table_name,
+          foreign_key: reflection.association_primary_key,
+          primary_key: reflection.association_foreign_key,
+          type: :belongs_to
+        },
+        {
+          name: model.to_s.underscore,
+          joins: model.to_s,
+          foreign_table: model.table_name,
+          foreign_key: reflection.association_primary_key,
+          primary_key: reflection.foreign_key,
+          type: :belongs_to
+        }
+      ]
+    }
+  end
+
+  def serializable_hash
+    models.map do |model|
+      foreign_keys =  foreign_keys_for(model)
+      # find association tables
+      model
+        .reflections
+        .select { |_, reflection| reflection.class_name.in?(models.map(&:to_s)) && reflection.macro == :has_and_belongs_to_many }
+        .each { |reflection_name, reflection| serialize_habtam_reflection(model, reflection) }
+      {
+        name: model.to_s,
+        table_name: model.table_name,
+        columns:
+          model
+            .column_types
+            .map { |column_name, column_type| serialized_column(column_name, column_type, model, foreign_keys) },
+        associations:
+          model
+            .reflections
+            .select { |_, reflection| reflection.class_name.in?(models.map(&:to_s)) }
+            .flat_map { |reflection_name, reflection| seriaized_association(reflection_name, reflection) }
+      }
+    end + @association_tables.values
+  end
+
+  def plurality_for(reflection)
+    case reflection.macro
+    when :belongs_to, :has_one
+      false
+    else
+      true
+    end
+  end
+end

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification
+name: watcher_data
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Nam Chu Hoai
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-10-01 00:00:00.000000000 Z
+dependencies: []
+description: Watcher Data
+email: nambrot@googlemail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/watcher.rb
+homepage: http://rubygems.org/gems/watcher_data
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.7
+signing_key: 
+specification_version: 4
+summary: Watcher Data
+test_files: []
+has_rdoc: