parse-stack 1.7.3 → 1.9.1

data/lib/parse/query/operation.rb

@@ -1,9 +1,8 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
-require 'active_support'
-require 'active_support/inflector'
-
+require "active_support"
+require "active_support/inflector"
 
 module Parse
 
@@ -36,7 +35,7 @@ module Parse
 
     # Whether this operation is defined properly.
     def valid?
-      ! (@operand.nil? || @operator.nil? || handler.nil?)
+      !(@operand.nil? || @operator.nil? || handler.nil?)
     end
 
     # @return [Parse::Constraint] the constraint class designed to handle
@@ -69,13 +68,11 @@ module Parse
 
     # Register a new symbol operator method mapped to a specific {Parse::Constraint}.
     def self.register(op, klass)
-        Operation.operators[op.to_sym] = klass
-        Symbol.send :define_method, op do |value = nil|
-          operation = Operation.new self, op
-          value.nil? ? operation : operation.constraint(value)
-        end
+      Operation.operators[op.to_sym] = klass
+      Symbol.send :define_method, op do |value = nil|
+        operation = Operation.new self, op
+        value.nil? ? operation : operation.constraint(value)
+      end
     end
-
   end
-
 end

data/lib/parse/query/ordering.rb

@@ -1,62 +1,59 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
-
 module Parse
-    # This class adds support for describing ordering for Parse queries. You can
-    # either order by ascending (asc) or descending (desc) order.
-    #
-    # Ordering is implemented similarly to constraints in which we add
-    # special methods to the Symbol class. The developer can then pass one
-    # or an array of fields (as symbols) and call the particular ordering
-    # polarity (ex. _:name.asc_ would create a Parse::Order where we want
-    # things to be sortd by the name field in ascending order)
-    # For more information about the query design pattern from DataMapper
-    # that inspired this, see http://datamapper.org/docs/find.html'
-    # @example
-    #   :name.asc # => Parse::Order by ascending :name
-    #   :like_count.desc # => Parse::Order by descending :like_count
-    #
-    class Order
-      # The Parse operators to indicate ordering direction.
-      ORDERING = {asc: '', desc: '-'}.freeze
-
-      # @!attribute [rw] field
-      # @return [Symbol] the name of the field
-      attr_accessor :field
+  # This class adds support for describing ordering for Parse queries. You can
+  # either order by ascending (asc) or descending (desc) order.
+  #
+  # Ordering is implemented similarly to constraints in which we add
+  # special methods to the Symbol class. The developer can then pass one
+  # or an array of fields (as symbols) and call the particular ordering
+  # polarity (ex. _:name.asc_ would create a Parse::Order where we want
+  # things to be sortd by the name field in ascending order)
+  # For more information about the query design pattern from DataMapper
+  # that inspired this, see http://datamapper.org/docs/find.html'
+  # @example
+  #   :name.asc # => Parse::Order by ascending :name
+  #   :like_count.desc # => Parse::Order by descending :like_count
+  #
+  class Order
+    # The Parse operators to indicate ordering direction.
+    ORDERING = { asc: "", desc: "-" }.freeze
 
-      # @!attribute [rw] direction
-      # The direction of the sorting. This is either `:asc` or `:desc`.
-      # @return [Symbol]
-      attr_accessor :direction
+    # @!attribute [rw] field
+    # @return [Symbol] the name of the field
+    attr_accessor :field
 
-      def initialize(field, order = :asc)
-        @field = field.to_sym || :objectId
-        @direction = order
-      end
+    # @!attribute [rw] direction
+    # The direction of the sorting. This is either `:asc` or `:desc`.
+    # @return [Symbol]
+    attr_accessor :direction
 
-      def field=(f)
-        @field = f.to_sym
-      end
-
-      # @return [String] the sort direction
-      def polarity
-        ORDERING[@direction] || ORDERING[:asc]
-      end # polarity
+    def initialize(field, order = :asc)
+      @field = field.to_sym || :objectId
+      @direction = order
+    end
 
-      # @return [String] the ordering as a string
-      def to_s
-        "" if @field.nil?
-         polarity + @field.to_s
-      end
+    def field=(f)
+      @field = f.to_sym
+    end
 
-      # @!visibility private
-      def inspect
-        "#{@direction.to_s}(#{@field.inspect})"
-      end
+    # @return [String] the sort direction
+    def polarity
+      ORDERING[@direction] || ORDERING[:asc]
+    end # polarity
 
-    end # Order
+    # @return [String] the ordering as a string
+    def to_s
+      "" if @field.nil?
+      polarity + @field.to_s
+    end
 
+    # @!visibility private
+    def inspect
+      "#{@direction.to_s}(#{@field.inspect})"
+    end
+  end # Order
 end
 
 # Extension to add all the operator instance methods to the Symbol classe
@@ -66,5 +63,4 @@ class Symbol
       Parse::Order.new self, sym
     end
   end # each
-
 end

data/lib/parse/stack.rb

@@ -2,27 +2,31 @@
 # frozen_string_literal: true
 
 require_relative "stack/version"
-require_relative 'client'
-require_relative 'query'
-require_relative 'model/object'
-require_relative 'webhooks'
-
+require_relative "client"
+require_relative "query"
+require_relative "model/object"
+require_relative "webhooks"
 
 module Parse
-  class Error < StandardError; end;
+  class Error < StandardError; end
+
   module Stack
+  end
+
+  # Special class to support Modernistik Hyperdrive server.
+  class Hyperdrive
     # Applies a remote JSON hash containing the ENV keys and values from a remote
     # URL. Values from the JSON hash are only applied to the current ENV hash ONLY if
     # it does not already have a value. Therefore local ENV values will take precedence
     # over remote ones. By default, it uses the url in environment value in 'CONFIG_URL' or 'HYPERDRIVE_URL'.
     # @param url [String] the remote url that responds with the JSON body.
     # @return [Boolean] true if the JSON hash was found and applied successfully.
-    def self.hyperdrive_config!(url = nil)
-      url ||= ENV["HYPERDRIVE_URL"] || ENV['CONFIG_URL']
+    def self.config!(url = nil)
+      url ||= ENV["HYPERDRIVE_URL"] || ENV["CONFIG_URL"]
       if url.present?
         begin
-          remote_config = JSON.load open( url )
-          remote_config.each do |key,value|
+          remote_config = JSON.load open(url)
+          remote_config.each do |key, value|
             k = key.upcase
             next unless ENV[k].nil?
             ENV[k] ||= value.to_s
@@ -37,4 +41,4 @@ module Parse
   end
 end
 
-require_relative 'stack/railtie' if defined?(::Rails)
+require_relative "stack/railtie" if defined?(::Rails)

data/lib/parse/stack/generators/rails.rb

@@ -1,42 +1,40 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
-require 'parse/stack'
-require 'parse/stack/tasks'
-require 'rails/generators'
-require 'rails/generators/named_base'
+require "parse/stack"
+require "parse/stack/tasks"
+require "rails/generators"
+require "rails/generators/named_base"
 
 # Module namespace to show up in the generators list for Rails.
 module ParseStack
-    # Adds support for rails when installing Parse::Stack to a Rails project.
-    class InstallGenerator < Rails::Generators::Base
-      source_root File.expand_path("../templates", __FILE__)
-
-      desc "This generator creates an initializer file at config/initializers"
-      # @!visibility private
-      def generate_initializer
-        copy_file "parse.rb", "config/initializers/parse.rb"
-        copy_file "model_user.rb", File.join("app/models", "user.rb")
-        copy_file "model_role.rb", File.join("app/models", "role.rb")
-        copy_file "model_session.rb", File.join("app/models", "session.rb")
-        copy_file "model_installation.rb", File.join("app/models", "installation.rb")
-        copy_file "webhooks.rb", File.join("app/models", "webhooks.rb")
-      end
-    end
+  # Adds support for rails when installing Parse::Stack to a Rails project.
+  class InstallGenerator < Rails::Generators::Base
+    source_root File.expand_path("../templates", __FILE__)
 
+    desc "This generator creates an initializer file at config/initializers"
     # @!visibility private
-    class ModelGenerator < Rails::Generators::NamedBase
-      source_root File.expand_path(__dir__ + "/templates")
-      desc "Creates a Parse::Object model subclass."
-      argument :attributes, type: :array, default: [], banner: "field:type field:type"
-      check_class_collision
+    def generate_initializer
+      copy_file "parse.rb", "config/initializers/parse.rb"
+      copy_file "model_user.rb", File.join("app/models", "user.rb")
+      copy_file "model_role.rb", File.join("app/models", "role.rb")
+      copy_file "model_session.rb", File.join("app/models", "session.rb")
+      copy_file "model_installation.rb", File.join("app/models", "installation.rb")
+      copy_file "webhooks.rb", File.join("app/models", "webhooks.rb")
+    end
+  end
 
-      # @!visibility private
-      def create_model_file
-        @allowed_types = Parse::Properties::TYPES - [:acl, :id, :relation]
-        template "model.erb", File.join("app/models", class_path, "#{file_name}.rb")
-      end
+  # @!visibility private
+  class ModelGenerator < Rails::Generators::NamedBase
+    source_root File.expand_path(__dir__ + "/templates")
+    desc "Creates a Parse::Object model subclass."
+    argument :attributes, type: :array, default: [], banner: "field:type field:type"
+    check_class_collision
 
+    # @!visibility private
+    def create_model_file
+      @allowed_types = Parse::Properties::TYPES - [:acl, :id, :relation]
+      template "model.erb", File.join("app/models", class_path, "#{file_name}.rb")
     end
-
+  end
 end

data/lib/parse/stack/generators/templates/model.erb

@@ -5,12 +5,11 @@ class <%= class_name %> < Parse::Object
   # You can change the inferred Parse table/collection name below
   # parse_class "<%= class_name.to_s.to_parse_class %>"
 <% attributes.each do |attr|
-  parse_type = attr.type.to_s.downcase.to_sym
-  unless @allowed_types.include?(parse_type)
-    puts "\n[Warning] Skipping property `#{attr.name}` with type `#{parse_type}`. Type should be one of #{@allowed_types}."
-    next
-  end
-%>
+     parse_type = attr.type.to_s.downcase.to_sym
+     unless @allowed_types.include?(parse_type)
+       puts "\n[Warning] Skipping property `#{attr.name}` with type `#{parse_type}`. Type should be one of #{@allowed_types}."
+       next
+     end %>
   property :<%= attr.name %>, :<%= parse_type -%>
 <% end %>
 

data/lib/parse/stack/generators/templates/model_installation.rb

@@ -1,4 +1,3 @@
-
 class Parse::Installation < Parse::Object
   # See: https://github.com/modernistik/parse-stack#parseinstallation
   # add additional properties here

data/lib/parse/stack/generators/templates/model_role.rb

@@ -1,4 +1,3 @@
-
 class Parse::Role < Parse::Object
   # See: https://github.com/modernistik/parse-stack#parserole
   # add additional properties here

data/lib/parse/stack/generators/templates/model_session.rb

@@ -1,4 +1,3 @@
-
 class Parse::Session < Parse::Object
   # See: https://github.com/modernistik/parse-stack#parsesession
   # add additional properties here

data/lib/parse/stack/generators/templates/model_user.rb

@@ -1,4 +1,3 @@
-
 class Parse::User < Parse::Object
   # add additional properties
 

data/lib/parse/stack/generators/templates/parse.rb

@@ -1,12 +1,12 @@
-require 'parse/stack'
+require "parse/stack"
 
 # Set your specific Parse keys in your ENV. For all connection options, see
 # https://github.com/modernistik/parse-stack#connection-setup
-Parse.setup app_id: ENV['PARSE_SERVER_APPLICATION_ID'],
-           api_key: ENV['PARSE_SERVER_REST_API_KEY'],
-        master_key: ENV['PARSE_SERVER_MASTER_KEY'], # optional
-        server_url: 'https://localhost:1337/parse'
-        # optional
-        #    logging: false,
-        #      cache: Moneta.new(:File, dir: 'tmp/cache'),
-        #    expires: 1 # cache ttl 1 second
+Parse.setup app_id: ENV["PARSE_SERVER_APPLICATION_ID"],
+            api_key: ENV["PARSE_SERVER_REST_API_KEY"],
+            master_key: ENV["PARSE_SERVER_MASTER_KEY"], # optional
+            server_url: "https://localhost:1337/parse"
+# optional
+#    logging: false,
+#      cache: Moneta.new(:File, dir: 'tmp/cache'),
+#    expires: 1 # cache ttl 1 second

data/lib/parse/stack/generators/templates/webhooks.rb

@@ -1,8 +1,7 @@
-
 # See: https://github.com/modernistik/parse-stack#cloud-code-webhooks
 Parse::Webhooks.route(:function, :helloWorld) do
   #  use the Parse::Payload instance methods in this block
-  name = params['name'].to_s #function params
+  name = params["name"].to_s #function params
 
   # will return proper error response
   # error!("Missing argument 'name'.") unless name.present?

data/lib/parse/stack/railtie.rb

@@ -5,16 +5,14 @@ module Parse
   module Stack
     # Support for adding rake tasks to a Rails project.
     class Railtie < ::Rails::Railtie
-
       rake_tasks do
-        require_relative 'tasks'
+        require_relative "tasks"
         Parse::Stack.load_tasks
       end
 
       generators do
-        require_relative 'generators/rails'
+        require_relative "generators/rails"
       end
-
     end
   end
 end

data/lib/parse/stack/tasks.rb

@@ -1,15 +1,14 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
-require_relative '../stack.rb'
-require 'active_support'
-require 'active_support/inflector'
-require 'active_support/core_ext'
-require 'rake'
-require 'rake/dsl_definition'
+require_relative "../stack.rb"
+require "active_support"
+require "active_support/inflector"
+require "active_support/core_ext"
+require "rake"
+require "rake/dsl_definition"
 
 module Parse
-
   module Stack
     # Loads and installs all Parse::Stack related tasks in a rake file.
     def self.load_tasks
@@ -22,42 +21,36 @@ module Parse
 
       # Installs the rake tasks.
       def install_tasks
-
         if defined?(::Rails)
-          unless Rake::Task.task_defined?('db:seed') || Rails.root.blank?
+          unless Rake::Task.task_defined?("db:seed") || Rails.root.blank?
             namespace :db do
               desc "Seeds your database with by loading db/seeds.rb"
-              task :seed => 'parse:env' do
-                load Rails.root.join("db","seeds.rb")
+              task :seed => "parse:env" do
+                load Rails.root.join("db", "seeds.rb")
               end
             end
           end
         end
 
         namespace :parse do
-
           task :env do
-
-            if Rake::Task.task_defined?('environment')
-              Rake::Task['environment'].invoke
+            if Rake::Task.task_defined?("environment")
+              Rake::Task["environment"].invoke
               if defined?(::Rails)
                 Rails.application.eager_load! if Rails.application.present?
               end
-
             end
           end
 
           task :verify_env => :env do
-
             unless Parse::Client.client?
               raise "Please make sure you have setup the Parse.setup configuration before invoking task. Usually done in the :environment task."
             end
 
-            endpoint = ENV['HOOKS_URL'] || ''
-            unless endpoint.starts_with?('http://') || endpoint.starts_with?('https://')
+            endpoint = ENV["HOOKS_URL"] || ""
+            unless endpoint.starts_with?("http://") || endpoint.starts_with?("https://")
               raise "The ENV variable HOOKS_URL must be a <http/s> url : '#{endpoint}'. Ex. https://12345678.ngrok.io/webhooks"
             end
-
           end
 
           desc "Run auto_upgrade on all of your Parse models."
@@ -69,92 +62,83 @@ module Parse
           end
 
           namespace :webhooks do
+            desc "Register local webhooks with Parse server"
+            task :register => :verify_env do
+              endpoint = ENV["HOOKS_URL"]
+              puts "Registering Parse Webhooks @ #{endpoint}"
+              Rake::Task["parse:webhooks:register:functions"].invoke
+              Rake::Task["parse:webhooks:register:triggers"].invoke
+            end
 
-          desc "Register local webhooks with Parse server"
-          task :register => :verify_env do
-            endpoint = ENV['HOOKS_URL']
-            puts "Registering Parse Webhooks @ #{endpoint}"
-            Rake::Task['parse:webhooks:register:functions'].invoke
-            Rake::Task['parse:webhooks:register:triggers'].invoke
-          end
-
-          desc "List all webhooks and triggers registered with the Parse Server"
-          task :list => :verify_env do
-            Rake::Task['parse:webhooks:list:functions'].invoke
-            Rake::Task['parse:webhooks:list:triggers'].invoke
-          end
+            desc "List all webhooks and triggers registered with the Parse Server"
+            task :list => :verify_env do
+              Rake::Task["parse:webhooks:list:functions"].invoke
+              Rake::Task["parse:webhooks:list:triggers"].invoke
+            end
 
-          desc "Remove all locally registered webhooks from the Parse Application."
-          task :remove => :verify_env do
-            Rake::Task['parse:webhooks:remove:functions'].invoke
-            Rake::Task['parse:webhooks:remove:triggers'].invoke
-          end
+            desc "Remove all locally registered webhooks from the Parse Application."
+            task :remove => :verify_env do
+              Rake::Task["parse:webhooks:remove:functions"].invoke
+              Rake::Task["parse:webhooks:remove:triggers"].invoke
+            end
 
-          namespace :list do
-            task :functions => :verify_env do
-              endpoint = ENV['HOOKS_URL'] || '-'
-              Parse.client.functions.each do |r|
-                name = r['functionName']
-                url = r['url']
-                star = url.starts_with?(endpoint) ? '*' : ' '
-                puts "[#{star}] #{name} -> #{url}"
+            namespace :list do
+              task :functions => :verify_env do
+                endpoint = ENV["HOOKS_URL"] || "-"
+                Parse.client.functions.each do |r|
+                  name = r["functionName"]
+                  url = r["url"]
+                  star = url.starts_with?(endpoint) ? "*" : " "
+                  puts "[#{star}] #{name} -> #{url}"
+                end
               end
-            end
 
-            task :triggers => :verify_env do
-              endpoint = ENV['HOOKS_URL'] || '-'
-              triggers = Parse.client.triggers.results
-              triggers.sort! { |x,y| [x['className'],x['triggerName']] <=> [y['className'], y['triggerName'] ] }
-              triggers.each do |r|
-                name = r['className']
-                trigger = r['triggerName']
-                url = r['url']
-                star = url.starts_with?(endpoint) ? '*' : ' '
-                puts "[#{star}] #{name}.#{trigger} -> #{url}"
+              task :triggers => :verify_env do
+                endpoint = ENV["HOOKS_URL"] || "-"
+                triggers = Parse.client.triggers.results
+                triggers.sort! { |x, y| [x["className"], x["triggerName"]] <=> [y["className"], y["triggerName"]] }
+                triggers.each do |r|
+                  name = r["className"]
+                  trigger = r["triggerName"]
+                  url = r["url"]
+                  star = url.starts_with?(endpoint) ? "*" : " "
+                  puts "[#{star}] #{name}.#{trigger} -> #{url}"
+                end
               end
             end
 
-          end
-
-          namespace :register do
-
-            task :functions => :verify_env do
-              endpoint = ENV['HOOKS_URL']
-              Parse::Webhooks.register_functions!(endpoint) do |name|
-                puts "[+] function - #{name}"
+            namespace :register do
+              task :functions => :verify_env do
+                endpoint = ENV["HOOKS_URL"]
+                Parse::Webhooks.register_functions!(endpoint) do |name|
+                  puts "[+] function - #{name}"
+                end
               end
-            end
 
-            task :triggers => :verify_env do
-              endpoint = ENV['HOOKS_URL']
-              Parse::Webhooks.register_triggers!(endpoint, {include_wildcard: true}) do |trigger,name|
-                puts "[+] #{trigger.to_s.ljust(12, ' ')} - #{name}"
+              task :triggers => :verify_env do
+                endpoint = ENV["HOOKS_URL"]
+                Parse::Webhooks.register_triggers!(endpoint, { include_wildcard: true }) do |trigger, name|
+                  puts "[+] #{trigger.to_s.ljust(12, " ")} - #{name}"
+                end
               end
             end
 
-          end
-
-          namespace :remove do
-
-            task :functions => :verify_env do
-              Parse::Webhooks.remove_all_functions! do |name|
-                puts "[-] function - #{name}"
+            namespace :remove do
+              task :functions => :verify_env do
+                Parse::Webhooks.remove_all_functions! do |name|
+                  puts "[-] function - #{name}"
+                end
               end
-            end
 
-            task :triggers => :verify_env do
-              Parse::Webhooks.remove_all_triggers! do |trigger,name|
-                puts "[-] #{trigger.to_s.ljust(12, ' ')} - #{name}"
+              task :triggers => :verify_env do
+                Parse::Webhooks.remove_all_triggers! do |trigger, name|
+                  puts "[-] #{trigger.to_s.ljust(12, " ")} - #{name}"
+                end
               end
             end
-
-          end
-
           end # webhooks
-
         end # webhooks namespace
       end
     end # Tasks
   end # Webhooks
-
 end # Parse