forest_liana 2.15.8 → 3.0.0.pre.beta.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9791d00f328850811605eff107ed34a518693051
-  data.tar.gz: 17321641b3f1432ec4bfb63b36a8add62a7493a3
+  metadata.gz: 0e4fb230ea35b62c0104cd977a4f072d21ada6d7
+  data.tar.gz: 82caa0a2892b39222840c79689c49354ccb387b7
 SHA512:
-  metadata.gz: 6e82b22b8081c3b734af33a21c25b830ea27a6b6441c885ef498ab46d32586a885bc0849d3a00f2248859a7ff8e9f208f62f23f6c38b1d116c2b803c6944688f
-  data.tar.gz: 40fae318883c99ccc3f48e634b652a158181fb0e3bd95b04bc61083a799f7f6ece1e6fc4715b00ae1c3f6139446dcee0e6c88bdd88dcf4bc73aa28325daf45a7
+  metadata.gz: 1994b07deb2e1a14cf6de0ebc22e431fd3cd5b5dcdc34e92847a7ec20585d4cd3961d2df41e252b82836b79dade492812a5007136e62bddd9e2370762c044a0a
+  data.tar.gz: 0a20dc05da425189c52941c29be9b503f0edeeed8545ca7f1040a7f3babfb15d0c281359b9089653e502ddcf5923fbeea1a97353e2fadce0e2697711d7c696ba

data/Rakefile

@@ -14,7 +14,7 @@ RDoc::Task.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
 load 'rails/tasks/engine.rake'
 
 

data/app/controllers/forest_liana/resources_controller.rb

@@ -83,7 +83,8 @@ module ForestLiana
         getter = ForestLiana::ResourceGetter.new(@resource, params)
         getter.perform
 
-        render serializer: nil, json: render_record_jsonapi(getter.record)
+        render serializer: nil, json:
+          serialize_model(get_record(getter.record), include: includes(getter))
       rescue => error
         FOREST_LOGGER.error "Record Show error: #{error}\n#{format_stacktrace(error)}"
         internal_server_error
@@ -102,7 +103,8 @@ module ForestLiana
           render serializer: nil, json: JSONAPI::Serializer.serialize_errors(
             creator.errors), status: 400
         elsif creator.record.valid?
-          render serializer: nil, json: render_record_jsonapi(creator.record)
+          render serializer: nil,
+            json: serialize_model(get_record(creator.record), include: record_includes)
         else
           render serializer: nil, json: JSONAPI::Serializer.serialize_errors(
             creator.record.errors), status: 400
@@ -125,7 +127,8 @@ module ForestLiana
           render serializer: nil, json: JSONAPI::Serializer.serialize_errors(
             updater.errors), status: 400
         elsif updater.record.valid?
-          render serializer: nil, json: render_record_jsonapi(updater.record)
+          render serializer: nil,
+            json: serialize_model(get_record(updater.record), include: record_includes)
         else
           render serializer: nil, json: JSONAPI::Serializer.serialize_errors(
             updater.record.errors), status: 400
@@ -170,7 +173,9 @@ module ForestLiana
     end
 
     def record_includes
-      ForestLiana::QueryHelper.get_one_association_names_string(@resource)
+      SchemaUtils.one_associations(@resource)
+        .select { |a| SchemaUtils.model_included?(a.klass) }
+        .map { |a| a.name.to_s }
     end
 
     def record_not_found
@@ -186,19 +191,6 @@ module ForestLiana
       is_sti_model? ? record.becomes(@resource) : record
     end
 
-    def render_record_jsonapi record
-      collection = ForestLiana::SchemaHelper.find_collection_from_model(@resource)
-      collection_fields = collection.fields.map { |field| field[:field] }
-      fields_to_serialize = {
-        ForestLiana.name_for(@resource) => collection_fields.join(',')
-      }
-
-      serialize_model(get_record(record), {
-        include: record_includes,
-        fields: fields_to_serialize
-      })
-    end
-
     def render_jsonapi getter
       records = getter.records.map { |record| get_record(record) }
       fields_to_serialize = fields_per_model(params[:fields], @resource)

data/app/controllers/forest_liana/stats_controller.rb

@@ -6,24 +6,14 @@ module ForestLiana
       before_action :find_resource, except: [:get_with_live_query]
     end
 
-    CHART_TYPE_VALUE = 'Value';
-    CHART_TYPE_PIE = 'Pie';
-    CHART_TYPE_LINE = 'Line';
-    CHART_TYPE_LEADERBOARD = 'Leaderboard';
-    CHART_TYPE_OBJECTIVE = 'Objective';
-
     def get
-      case params[:type]
-      when CHART_TYPE_VALUE
+      case params[:type].try(:downcase)
+      when 'value'
         stat = ValueStatGetter.new(@resource, params)
-      when CHART_TYPE_PIE
+      when 'pie'
         stat = PieStatGetter.new(@resource, params)
-      when CHART_TYPE_LINE
+      when 'line'
         stat = LineStatGetter.new(@resource, params)
-      when CHART_TYPE_OBJECTIVE
-        stat = ObjectiveStatGetter.new(@resource, params)
-      when CHART_TYPE_LEADERBOARD
-        stat = LeaderboardStatGetter.new(@resource, params)
       end
 
       stat.perform

data/app/models/forest_liana/model/action.rb

@@ -4,14 +4,68 @@ class ForestLiana::Model::Action
   include ActiveModel::Serialization
   extend ActiveModel::Naming
 
-  # TODO: Remove :global option when we remove the deprecation warning.
-  attr_accessor :id, :name, :endpoint, :http_method, :fields, :redirect,
-    :global, :type, :download
+  attr_accessor :id, :name, :base_url, :endpoint, :http_method, :fields, :redirect,
+    :type, :download
 
   def initialize(attributes = {})
+    if attributes.key?(:global)
+      FOREST_LOGGER.error "REMOVED OPTION: The support for Smart Action \"global\" option is now " \
+        "removed. Please set \"type: 'global'\" instead of \"global: true\" for the " \
+        "\"#{attributes[:name]}\" Smart Action."
+    end
+
+
+    if attributes.key?(:type) && !['bulk', 'global', 'single'].include?(attributes[:type])
+      FOREST_LOGGER.warn "Please set a valid Smart Action type (\"bulk\", \"global\" or " \
+        "\"single\") for the \"#{attributes[:name]}\" Smart Action."
+    end
+
     attributes.each do |name, value|
       send("#{name}=", value)
     end
+
+    @fields ||= []
+
+    has_fields_without_name = false
+
+    @fields.delete_if do |field|
+      if field.key?(:field)
+        false
+      else
+        has_fields_without_name = true
+        true
+      end
+    end
+
+    @fields.map! do |field|
+      if field.key?(:isRequired)
+        FOREST_LOGGER.warn "DEPRECATION WARNING: isRequired on field \"#{field[:field]}\" is deprecated. Please use is_required."
+        field[:is_required] = !!field[:isRequired]
+        field.delete(:isRequired)
+      end
+
+      field[:type] = "String" unless field.key?(:type)
+      field[:default_value] = nil unless field.key?(:default_value)
+      field[:enums] = nil unless field.key?(:enums)
+      field[:is_required] = false unless field.key?(:is_required)
+      field[:reference] = nil unless field.key?(:reference)
+      field[:description] = nil unless field.key?(:description)
+      field[:widget] = nil unless field.key?(:widget)
+      field
+    end
+
+    if has_fields_without_name
+      FOREST_LOGGER.warn "Please set a name to all your \"#{@name}\" Smart Action fields " \
+        "(Smart Actions fields without name are ignored)."
+    end
+
+    dasherized_name = @name.downcase.gsub!(" ", "-") unless @name.nil?
+    @endpoint ||= "forest/actions/#{dasherized_name}" unless dasherized_name.nil?
+    @http_method ||= "POST"
+    @redirect ||= nil
+    @base_url ||= nil
+    @type ||= "bulk"
+    @download ||= false
   end
 
   def persisted?

data/app/models/forest_liana/model/collection.rb

@@ -5,21 +5,49 @@ class ForestLiana::Model::Collection
   extend ActiveModel::Naming
 
   attr_accessor :name, :fields, :actions, :segments, :only_for_relationships,
-    :is_virtual, :is_read_only, :is_searchable, :display_name, :icon,
+    :is_virtual, :is_read_only, :is_searchable, :icon,
     :integration, :pagination_type, :search_fields,
     # TODO: Remove once lianas prior to 2.0.0 are not supported anymore.
     :name_old
 
   def initialize(attributes = {})
-    @actions = []
-    @segments = []
-    @is_searchable = true
-    @is_read_only = false
-    @search_fields = nil
-
     attributes.each do |name, value|
       send("#{name}=", value)
     end
+
+    init_properties_with_default
+  end
+
+  def init_properties_with_default
+    @name_old ||= @name
+    @is_virtual ||= false
+    @icon ||= nil
+    @is_read_only ||= false
+    @is_searchable = true if @is_searchable.nil?
+    @only_for_relationships ||= false
+    @pagination_type ||= "page"
+    @search_fields ||= nil
+    @fields ||= []
+    @actions ||= []
+    @segments ||= []
+
+    @fields = @fields.map do |field|
+      field[:type] = "String" unless field.key?(:type)
+      field[:default_value] = nil unless field.key?(:default_value)
+      field[:enums] = nil unless field.key?(:enums)
+      field[:integration] = nil unless field.key?(:integration)
+      field[:is_filterable] = true unless field.key?(:is_filterable)
+      field[:is_read_only] = false unless field.key?(:is_read_only)
+      field[:is_required] = false unless field.key?(:is_required)
+      field[:is_sortable] = true unless field.key?(:is_sortable)
+      field[:is_virtual] = false unless field.key?(:is_virtual)
+      field[:reference] = nil unless field.key?(:reference)
+      field[:inverse_of] = nil unless field.key?(:inverse_of)
+      field[:relationship] = nil unless field.key?(:relationship)
+      field[:widget] = nil unless field.key?(:widget)
+      field[:validations] = nil unless field.key?(:validations)
+      field
+    end
   end
 
   def persisted?
@@ -32,13 +60,13 @@ class ForestLiana::Model::Collection
 
   def fields_smart_belongs_to
     fields.select do |field|
-      field[:'is-virtual'] && field[:type] == 'String' && !field[:reference].nil?
+      field[:'is_virtual'] && field[:type] == 'String' && !field[:reference].nil?
     end
   end
 
   def string_smart_fields_names
     fields
-      .select { |field| field[:'is-virtual'] && field[:type] == 'String' }
+      .select { |field| field[:'is_virtual'] && field[:type] == 'String' }
       .map { |field| field[:field].to_s }
   end
 end

data/app/models/forest_liana/model/segment.rb

@@ -10,7 +10,7 @@ class ForestLiana::Model::Segment
     attributes.each do |name, value|
       send("#{name}=", value)
     end
-    
+
     @where = block if block
   end
 

data/app/serializers/forest_liana/schema_serializer.rb

@@ -0,0 +1,83 @@
+class ForestLiana::SchemaSerializer
+  def initialize collections, meta
+    @collections = collections
+    @meta = meta
+    @data = []
+    @included = []
+  end
+
+  def serialize
+    populate_data_and_included
+    {
+      data: @data,
+      included: @included,
+      meta: @meta
+    }
+  end
+
+  private
+
+  def populate_data_and_included
+    @collections.each do |collection|
+      serialize_collection(collection)
+    end
+  end
+
+  def serialize_collection collection
+    collection_serialized = {
+      id: collection['name'],
+      type: 'collections',
+      attributes: {},
+      relationships: {
+        actions: {
+          data: []
+        },
+        segments: {
+          data: []
+        }
+      }
+    }
+
+    collection.each do |attribute, value|
+      if attribute == 'actions'
+        value.each do |action|
+          action_id = define_child_id(collection_serialized[:id], action['name'])
+          collection_serialized[:relationships][:actions][:data] << format_child_pointer('actions', action_id)
+          @included << format_child_content('actions', action_id, action)
+        end
+      elsif attribute == 'segments'
+        value.each do |segment|
+          segment_id = define_child_id(collection_serialized[:id], segment['name'])
+          collection_serialized[:relationships][:segments][:data] << format_child_pointer('segments', segment_id)
+          @included << format_child_content('segments', segment_id, segment)
+        end
+      else
+        collection_serialized[:attributes][attribute.to_sym] = value;
+      end
+    end
+
+    @data << collection_serialized
+  end
+
+  def define_child_id collection_id, object_id
+    "#{collection_id}.#{object_id}"
+  end
+
+  def format_child_pointer type, id
+    { id: id, type: type }
+  end
+
+  def format_child_content type, id, object
+    child_serialized = {
+      id: id,
+      type: type,
+      attributes: {}
+    }
+
+    object.each do |attribute, value|
+      child_serialized[:attributes][attribute.to_sym] = value;
+    end
+
+    child_serialized
+  end
+end

data/app/serializers/forest_liana/serializer_factory.rb

@@ -35,12 +35,6 @@ module ForestLiana
         "ForestLiana::StripeBankAccountSerializer"
       elsif active_record_class == ForestLiana::Model::Stat
         "ForestLiana::StatSerializer"
-      elsif active_record_class == ForestLiana::Model::Collection
-        "ForestLiana::CollectionSerializer"
-      elsif active_record_class == ForestLiana::Model::Action
-        "ForestLiana::ActionSerializer"
-      elsif active_record_class == ForestLiana::Model::Segment
-        "ForestLiana::SegmentSerializer"
       elsif active_record_class == ForestLiana::MixpanelEvent
         "ForestLiana::MixpanelEventSerializer"
       else
@@ -179,27 +173,17 @@ module ForestLiana
 
       unless @is_smart_collection
         attributes(active_record_class).each do |attribute|
-          serializer.attribute(attribute) do |x|
-            begin
-              object.send(attribute)
-            rescue
-              nil
-            end
-          end
+          serializer.attribute(attribute)
         end
 
         # NOTICE: Format time type fields during the serialization.
         attributes_time(active_record_class).each do |attribute|
           serializer.attribute(attribute) do |x|
-            begin
-              value = object.send(attribute)
-              if value
-                match = /(\d{2}:\d{2}:\d{2})/.match(value.to_s)
-                (match && match[1]) ? match[1] : nil
-              else
-                nil
-              end
-            rescue
+            value = object.send(attribute)
+            if value
+              match = /(\d{2}:\d{2}:\d{2})/.match(value.to_s)
+              (match && match[1]) ? match[1] : nil
+            else
               nil
             end
           end
@@ -208,38 +192,22 @@ module ForestLiana
         # NOTICE: Format serialized fields.
         attributes_serialized(active_record_class).each do |attr, serialization|
           serializer.attribute(attr) do |x|
-            begin
-              value = object.send(attr)
-              value ? value.to_json : nil
-            rescue
-              nil
-            end
+            value = object.send(attr)
+            value ? value.to_json : nil
           end
         end
 
         # NOTICE: Format CarrierWave url attribute
         if active_record_class.respond_to?(:mount_uploader)
           active_record_class.uploaders.each do |key, value|
-            serializer.attribute(key) do |x|
-              begin
-                object.send(key).try(:url)
-              rescue
-                nil
-              end
-            end
+            serializer.attribute(key) { |x| object.send(key).try(:url) }
           end
         end
 
         # NOTICE: Format Paperclip url attribute
         if active_record_class.respond_to?(:attachment_definitions)
           active_record_class.attachment_definitions.each do |key, value|
-            serializer.attribute(key) do |x|
-              begin
-                object.send(key)
-              rescue
-                nil
-              end
-            end
+            serializer.attribute(key) { |x| object.send(key) }
           end
         end
 
@@ -249,11 +217,7 @@ module ForestLiana
           active_record_class.acts_as_taggable.respond_to?(:to_a)
           active_record_class.acts_as_taggable.to_a.each do |key, value|
             serializer.attribute(key) do |x|
-              begin
-                object.send(key).map(&:name)
-              rescue
-                nil
-              end
+              object.send(key).map(&:name)
             end
           end
         end
@@ -307,7 +271,8 @@ module ForestLiana
         serializer.send(:has_many, :mixpanel_last_events) { }
       end
 
-      ForestLiana::SerializerFactory.define_serializer(active_record_class, serializer)
+      ForestLiana::SerializerFactory.define_serializer(active_record_class,
+                                                       serializer)
 
       serializer
     end