ember-schema 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bbd2105d4a845ce5bc89f0a32104a85a623ebdb5
-  data.tar.gz: 0eaf1ef3bd0eb38ca5499468bc9ea83c6fbb3442
+  metadata.gz: 916f39406eef607fbc18202a2153630ae903354c
+  data.tar.gz: 9003198bddc8dc9a39a865ed89d229d7c8005d7c
 SHA512:
-  metadata.gz: 87905e6144ee9f53e0f0a58238ff2f1dea69a75fe2dd98e651df3692e53ef0e6ae968f2c51ce6daaf7f07f0ccbae879c5efcd3ce5ec45a39fb4104e62104f205
-  data.tar.gz: 4f5a879903b6442f9187c163d85598a191ab26543dd6049cfc2199edb0cf1e176da88e0c7bf8599ddc6889d2410e97b982b4faaa9afafb76d5fd17627cc61bfa
+  metadata.gz: 7415f1c58de8c8b7cf23818763ebd8108ae93fc5592b289ab11e4184b751f7bff6d12bc48053b23061d96228de8ed41de4e2dc9783f1cb8cb969beea11cfd027
+  data.tar.gz: f88f864da8831648a261a8e38cb2ffa7859f9caed9b444688309ec7d3f833818ff92faaec4e83e74e3e82550d990255088fcc2cbc05ff77b12c2ae8a1ae5b32f

data/README.md

@@ -1,4 +1,4 @@
-# Ember::Schema
+# UnchartedCode Ember::Schema
 
 Generates a json schema for restpack_serializer models
 
@@ -18,7 +18,17 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+The schema will automatically be generated when you run db:migrate
+
+```
+rake db:migrate
+```
+
+and it will show up in db/schema.js. You can also fire it off manually like this
+
+```
+rake db:schema:ember
+```
 
 ## Contributing
 

data/lib/ember/schema.rb

@@ -1,44 +1,58 @@
 require "rake"
 require "ember/schema/version"
+require "ember/schema/rest_pack"
+require "ember/schema/active_model"
 
 module Ember
   module Schema
-    def self.generate
+    def self.generate(type)
+      return unless const_defined?("::#{type.to_s}")
+
       schema_hash = {}
-      # Rails.application.eager_load! # populate descendants
 
-      RestPack::Serializer.class_map.sort_by { |s| s[0] }.map { |s| s[1] }.each do |serializer_class|
+      case type.to_s
+        when "RestPack::Serializer"
+          generator = RestPack.new
+        when "ActiveModel::Serializer"
+          generator = ActiveModel.new
+        else
+          return
+      end
+
+      generator.serializers.each do |serializer_class|
         begin
           next if serializer_class == ApplicationSerializer
           next if serializer_class.respond_to?(:ignore) && serializer_class.ignore
-          klass = get_klass(serializer_class)
+
+          klass = generator.get_klass(serializer_class)
           if klass.present?
             # if we are dealing with a polymorphic class, then process accordingly
             if klass.respond_to?(:base_class) && klass != klass.base_class
               p "--Skipping inherited class: '#{klass.name}', it will be processed with parent"
               next
             end
-            schema = schema(serializer_class, klass)
-            name = klass.name.camelize
+
+            schema = generator.schema(serializer_class, klass)
+            name = generator.camelize(serializer_class, klass)
             schema_hash[name] = schema
             p "#{klass.name}: Complete"
             # Check for inherited serializer classes now
-            serializer_class.descendants.sort_by { |s| s.name }.each do |child_serializer_class|
+            generator.descendants(serializer_class).each do |child_serializer_class|
               begin
                 # to be inherited, it has to have a subclass thats not the base and a klass that is inherited
                 if child_serializer_class == ApplicationSerializer || # skip, default class
                   child_serializer_class.superclass == ApplicationSerializer || # skip, base is default class, not inherited
-                  child_serializer_class.superclass == RestPack::Serializer || # skip, default class
+                  child_serializer_class.superclass == generator.superclass || # skip, default class
                   child_serializer_class == serializer_class # skip serializer is itself
                   next
                 end
-                child_klass = get_klass(child_serializer_class)
+                child_klass = generator.get_klass(child_serializer_class)
                 if child_klass.present?
                   # if we are dealing with a polymorphic class, then process accordingly
                   next unless child_klass.respond_to?(:base_class) # this is not active record
                   next if child_klass == child_klass.base_class # this is the base class
                   next unless child_klass.base_class == klass # this is not a subclass of klass
-                  diff_schema = inherited_schema(child_serializer_class, child_klass, schema)
+                  diff_schema = inherited_schema(child_serializer_class, child_klass, schema, generator)
                   child_name = child_klass.name.camelize
                   # Modify parents schema
                   schema[:descendants] ||= {}
@@ -62,61 +76,8 @@ module Ember
 
   private
 
-    def self.get_klass(serializer)
-      return serializer.model_class
-      # module_name = serializer.name.deconstantize
-      # class_name = serializer.root_name.camelize
-      # full_name = [module_name, class_name].reject(&:empty?).join("::")
-      # begin
-      #   return full_name.constantize
-      # rescue => e
-      #   p " - Unable to find model: '#{full_name}'. Skipping schema processing."
-      #   return nil
-      # end
-    end
-
-    def self.schema(serializer, klass)
-      columns = if klass.respond_to? :columns_hash then klass.columns_hash else {} end
-
-      attrs = {}
-      (serializer.serializable_attributes || {}).each do |id, name|
-        options = serializer.serializable_attributes_options[id] || {}
-        if options[:type].present?
-          attrs[name] = options[:type].to_s
-        else
-          # If no type is given, attempt to get it from the Active Model class
-          if column = columns[name.to_s]
-            attrs[name] = column.type
-          else
-            # Other wise default to string
-            attrs[name] = "string"
-          end
-        end
-      end
-
-      associations = {}
-
-      serializer.can_include.each do |association_name|
-        #association = association_class.new(attr, self)
-
-        if model_association = klass.reflect_on_association(association_name)
-          # Real association.
-          associations[association_name] = { model_association.macro => model_association.class_name.pluralize.underscore.downcase }
-        # elsif model_association = get_type(association)
-        #   # Computed association. We could infer has_many vs. has_one from
-        #   # the association class, but that would make it different from
-        #   # real associations, which read has_one vs. belongs_to from the
-        #   # model.
-        #   associations[association.key] = { model_association => association.key }
-        end
-        #associations[association_name][:async] = (association.options[:async] || false) if association.options.has_key? :async
-      end
-
-      return { :attributes => attrs, :associations => associations }
-    end
-
-    def self.inherited_schema(serializer, klass, base_schema)
-      schema = schema(serializer, klass)
+    def self.inherited_schema(serializer, klass, base_schema, generator)
+      schema = generator.schema(serializer, klass)
 
       schema_diff = {}
       schema_diff[:attributes] = diff(base_schema[:attributes], schema[:attributes])

data/lib/ember/schema/active_model.rb

@@ -0,0 +1,84 @@
+module Ember
+  module Schema
+    class ActiveModel
+      def superclass
+        ::ActiveModel::Serializer
+      end
+
+      def serializers
+        ::ActiveModel::Serializer.descendants.sort_by(&:final_name)
+      end
+
+      def descendants(serializer)
+        serializers
+      end
+
+      def get_klass(serializer)
+        module_name = serializer.name.deconstantize
+        class_name = serializer.root_name.camelize
+        full_name = [module_name, class_name].reject(&:empty?).join("::")
+        begin
+          return full_name.constantize
+        rescue => e
+          p " - Unable to find model: '#{full_name}'. Skipping schema processing."
+          return nil
+        end
+      end
+
+      def camelize(serializer, klass)
+        (serializer._root || klass.name).camelize
+      end
+
+      def schema(serializer, klass)
+        columns = if klass.respond_to? :columns_hash then klass.columns_hash else {} end
+
+        attrs = {}
+        serializer._attributes.each do |name|
+          option = serializer._options[name] || {}
+          if option[:type].present?
+            attrs[name] = option[:type]
+          else
+            # If no type is given, attempt to get it from the Active Model class
+            if column = columns[name.to_s]
+              attrs[name] = column.type
+            else
+              # Other wise default to string
+              attrs[name] = "string"
+            end
+          end
+        end
+
+        associations = {}
+        serializer._associations.each do |attr, association|
+          #association = association_class.new(attr, self)
+
+          if model_association = get_type(association)
+            # Real association.
+            association_class_name = association.options[:class_name]
+            key = association.key.gsub(/_id/,'')
+            associations[key] = { model_association => association_class_name || key }
+            associations[key][:async] = (association.options[:async] || false) if association.options.has_key? :async
+            associations[key][:polymorphic] = (association.options[:polymorphic] || false) if association.options.has_key? :polymorphic
+          else
+            # Computed association. We could infer has_many vs. has_one from
+            # the association class, but that would make it different from
+            # real associations, which read has_one vs. belongs_to from the
+            # model.
+            associations[association.key] = nil
+          end
+        end
+
+        return { :attributes => attrs, :associations => associations }
+      end
+
+      def get_type(association)
+        if association.is_a? ::ActiveModel::Serializer::Association::HasMany
+          return "has_many"
+        elsif association.is_a? ::ActiveModel::Serializer::Association::HasOne
+          return "belongs_to"
+        end
+        return nil
+      end
+    end
+  end
+end

data/lib/ember/schema/rest_pack.rb

@@ -0,0 +1,56 @@
+module Ember
+  module Schema
+    class RestPack
+      def superclass
+        ::RestPack::Serializer
+      end
+
+      def serializers
+        ::RestPack::Serializer.class_map.sort_by { |s| s[0] }.map { |s| s[1] }
+      end
+
+      def descendants(serializer)
+        serializer.descendants.sort_by { |s| s.name }
+      end
+
+      def get_klass(serializer)
+        serializer.model_class
+      end
+
+      def camelize(serializer, klass)
+        klass.name.camelize
+      end
+
+      def schema(serializer, klass)
+        columns = if klass.respond_to? :columns_hash then klass.columns_hash else {} end
+
+        attrs = {}
+        (serializer.serializable_attributes || {}).each do |id, name|
+          options = serializer.serializable_attributes_options[id] || {}
+          if options[:type].present?
+            attrs[name] = options[:type].to_s
+          else
+            # If no type is given, attempt to get it from the Active Model class
+            if column = columns[name.to_s]
+              attrs[name] = column.type
+            else
+              # Other wise default to string
+              attrs[name] = "string"
+            end
+          end
+        end
+
+        associations = {}
+
+        serializer.can_include.each do |association_name|
+          if model_association = klass.reflect_on_association(association_name)
+            # Real association
+            associations[association_name] = { model_association.macro => model_association.class_name.pluralize.underscore.downcase }
+          end
+        end
+
+        return { :attributes => attrs, :associations => associations }
+      end
+    end
+  end
+end

data/lib/ember/schema/version.rb

@@ -1,5 +1,5 @@
 module Ember
   module Schema
-    VERSION = "0.0.1"
+    VERSION = "0.0.2"
   end
 end

data/lib/tasks/ember.rake

@@ -2,7 +2,13 @@ namespace :db do
   namespace :schema do
     desc 'Regenerate the Ember schema.js based on the serializers'
     task :ember => :environment do
-      schema_hash = Ember::Schema.generate
+      if defined? RestPack::Serializer
+        schema_hash = Ember::Schema.generate(RestPack::Serializer)
+      else
+        Rails.application.eager_load! # populate descendants
+        schema_hash = Ember::Schema.generate(ActiveModel::Serializer)
+      end
+
       schema_json = JSON.pretty_generate(schema_hash)
       File.open 'db/schema.js', 'w' do |f|
         f << schema_json

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ember-schema
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Nathan Palmer
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-11 00:00:00.000000000 Z
+date: 2015-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -67,6 +67,8 @@ files:
 - Rakefile
 - ember-schema.gemspec
 - lib/ember/schema.rb
+- lib/ember/schema/active_model.rb
+- lib/ember/schema/rest_pack.rb
 - lib/ember/schema/version.rb
 - lib/tasks/ember.rake
 homepage: ''