praxis 0.21 → 2.0.pre.3

data/.ruby-version

@@ -1 +0,0 @@
-2.3

data/lib/praxis/extensions/mapper_selectors.rb

@@ -1,16 +0,0 @@
-module Praxis
-  module Extensions
-    module MapperSelectors
-      extend ActiveSupport::Concern
-      include FieldExpansion
-
-      def set_selectors
-        return unless self.media_type.respond_to?(:domain_model) &&
-          self.media_type.domain_model < Praxis::Mapper::Resource
-
-        resolved = Praxis::MediaType::FieldResolver.resolve(self.media_type, self.expanded_fields)
-        identity_map.add_selectors(self.media_type.domain_model, resolved)
-      end
-    end
-  end
-end

data/lib/praxis/media_type_collection.rb

@@ -1,127 +0,0 @@
-module Praxis
-
-  module StructCollection
-    def self.included(klass)
-      klass.instance_eval do
-        include(Enumerable)
-      end
-    end
-
-    def _members=(members)
-      @members = members
-    end
-
-    def _members
-      @members || []
-    end
-
-    def each
-      _members.each { |member| yield(member) }
-    end
-  end
-
-  class MediaTypeCollection < MediaType
-    include Enumerable
-
-    class << self
-      attr_accessor :member_attribute
-    end
-
-    def self.inherited(klass)
-      warn "DEPRECATION: MediaTypeCollection is deprecated and will be removed by 1.0"
-      super
-    end
-
-    def self._finalize!
-      super
-
-      if const_defined?(:Struct, false)
-        self::Struct.instance_eval do
-          include StructCollection
-        end
-      end
-    end
-
-    def self.member_type(type=nil)
-      return ( @member_attribute ? @member_attribute.type : nil) unless type
-      raise ArgumentError, "invalid type: #{type.name}" unless type < MediaType
-
-      member_options = {}
-      @member_attribute = Attributor::Attribute.new type, member_options
-    end
-
-    def self.example(context=nil, options: {})
-      result = super
-
-      context = case context
-      when nil
-        ["#{self.name}-#{values.object_id.to_s}"]
-      when ::String
-        [context]
-      else
-        context
-      end
-
-      members = []
-      size = rand(3) + 1
-
-      size.times do |i|
-        subcontext = context + ["at(#{i})"]
-        members << @member_attribute.example(subcontext)
-      end
-
-      result.object._members = members
-      result
-    end
-
-    def self.load(value,context=Attributor::DEFAULT_ROOT_CONTEXT, **options)
-      if value.kind_of?(String)
-        value = JSON.parse(value)
-      end
-
-      case value
-      when nil, self
-        value
-      when Hash
-        # Need to parse/deserialize first
-        self.new(self.attribute.load(value,context, **options))
-      when Array, Praxis::Mapper::ResourceDecorator
-        object = self.attribute.load({})
-        object._members = value.collect { |subvalue| @member_attribute.load(subvalue) }
-        self.new(object)
-      else
-        # Just wrap whatever value
-        self.new(value)
-      end
-    end
-
-    def self.describe(shallow = false)
-      hash = super
-      hash[:member_attribute] = member_attribute.describe(true)
-      hash
-    end
-
-    def self.member_view(name, using: nil)
-      if using
-        member_view = self.member_type.view(using)
-        return self.views[name] = CollectionView.new(name, self.member_type, member_view)
-      end
-
-      self.views[name]
-    end
-
-
-    def each
-      @object.each { |member| yield(member) }
-    end
-
-
-    def validate(context=Attributor::DEFAULT_ROOT_CONTEXT)
-      errors = super
-      self.each_with_object(errors) do |member, errors|
-        errors.push(*member.validate(context))
-      end
-    end
-
-  end
-end

data/lib/praxis/plugins/praxis_mapper_plugin.rb

@@ -1,246 +0,0 @@
-require 'praxis-mapper'
-require 'singleton'
-
-require 'terminal-table'
-
-# Plugin for applications which use the 'praxis-mapper' gem.
-#
-# This plugin provides the following features:
-#   1. Sets up the PraxisMapper::IdentityMap for your application and assigns
-#      it to the controller's request.identity_map for access from your
-#      application.
-#   2. Connects to your database and dumps a log of database interaction stats
-#      (if enabled via the :log_stats option).
-#
-# This plugin accepts one of the following options:
-#   1. config_file: A String indicating the path where this plugin's config
-#      file exists.
-#   2. config_data: A Hash of data that is merged into the YAML hash loaded
-#      from config_file.
-#
-# The config_data Hash contains the following keys:
-#   1. repositories: A Hash containing the configs for the database repositories
-#      queried through praxis-mapper. This parameter is a Hash where a key is
-#      the identifier for a repository and the value is the options one
-#      would give to the 'sequel' gem. For example:
-#           repositories: {
-#             default: {
-#               host: 127.0.0.1,
-#               username: root,
-#               password: nil,
-#               database: myapp_dev,
-#               adapter: mysql2
-#             }
-#           }
-#   2. log_stats: A String indicating what kind of DB stats you would like
-#      output into the Praxis::Application.instance.logger app log. Possible
-#      values are: "detailed", "short", and "skip" (i.e. do not print the stats
-#      at all).
-#   3. stats_log_level: the logging level with which the statistics should be logged.
-#
-# See http://praxis-framework.io/reference/plugins/ for further details on how
-# to use a plugin and pass it options.
-#
-module Praxis
-  module Plugins
-    module PraxisMapperPlugin
-      include Praxis::PluginConcern
-
-      class RepositoryConfig < Attributor::Hash
-        self.key_type = String
-
-        keys allow_extra: true do
-          key 'type', String, default: 'sequel'
-          extra 'connection_settings'
-        end
-
-      end
-
-
-      class Plugin < Praxis::Plugin
-        include Singleton
-
-        def initialize
-          @options = {
-            config_file: 'config/praxis_mapper.yml',
-            config_data: {
-              repositories: {}
-            }
-          }
-        end
-
-        def config_key
-          :praxis_mapper
-        end
-
-        def prepare_config!(node)
-          node.attributes do
-            attribute :log_stats, String, values: ['detailed', 'short', 'skip'], default: 'detailed'
-            attribute :stats_log_level, Symbol, values: [:fatal,:error,:warn,:info,:debug], default: :info
-            attribute :repositories, Attributor::Hash.of(key: String, value: RepositoryConfig)
-          end
-        end
-
-        # Make our own custom load_config! method
-        def load_config!
-          config_file_path = application.root + options[:config_file]
-          result = config_file_path.exist? ? YAML.load_file(config_file_path) : {}
-          result.merge(@options[:config_data])
-        end
-
-        def setup!
-          self.config.repositories.each do |repository_name, repository_config|
-            type = repository_config['type']
-            connection_settings = repository_config['connection_settings']
-
-            case type
-            when 'sequel'
-              self.setup_sequel_repository(repository_name, connection_settings)
-            else
-              raise "unsupported repository type: #{type}"
-            end
-          end
-
-          log_stats = PraxisMapperPlugin::Plugin.instance.config.log_stats
-          unless log_stats == 'skip'
-            Praxis::Notifications.subscribe 'praxis.request.all' do |name, *junk, payload|
-              if (payload[:request].identity_map?)
-                identity_map = payload[:request].identity_map
-                PraxisMapperPlugin::Statistics.log(payload[:request], identity_map, log_stats)
-              end
-            end
-          end
-        end
-
-        def setup_sequel_repository(name, settings)
-          db = Sequel.connect(settings.dump.symbolize_keys)
-
-          Praxis::Mapper::ConnectionManager.setup do
-            repository(name.to_sym) { db }
-          end
-        end
-      end
-
-      module Request
-        def identity_map
-          @identity_map ||= Praxis::Mapper::IdentityMap.new
-        end
-
-        def identity_map=(map)
-          @identity_map = map
-        end
-
-        def identity_map?
-          !@identity_map.nil?
-        end
-
-        def silence_mapper_stats
-          @silence_mapper_stats
-        end
-
-        def silence_mapper_stats=(value)
-          @silence_mapper_stats = value
-        end
-
-      end
-
-      module Controller
-        extend ActiveSupport::Concern
-
-        included do
-          # Ensure we call #release on any identity map
-          # that may be set by the controller after the action
-          # completes.
-          around :action do |controller, callee|
-            begin
-              callee.call
-            ensure
-              if controller.request.identity_map?
-                controller.request.identity_map.release
-              end
-            end
-          end
-        end
-
-        def identity_map
-          request.identity_map
-        end
-
-      end
-
-      module Statistics
-
-        def self.log(request, identity_map, log_stats)
-          return if identity_map.nil?
-          return if request.silence_mapper_stats == true
-          if identity_map.queries.empty?
-            self.to_logger "No database interactions observed."
-            return
-          end
-
-
-          case log_stats
-          when 'detailed'
-            self.detailed(identity_map)
-          when 'short'
-            self.short(identity_map)
-          when 'skip'
-            # Shouldn't receive this. But anyway...no-op.
-          end
-        end
-
-        def self.detailed(identity_map)
-          stats_by_model = identity_map.query_statistics.sum_totals_by_model
-          stats_total = identity_map.query_statistics.sum_totals
-          fields = [ :query_count, :records_loaded, :datastore_interactions, :datastore_interaction_time]
-          rows = []
-
-          total_models_loaded = 0
-          # stats per model
-          stats_by_model.each do |model, totals|
-            total_values = totals.values_at(*fields)
-            self.round_fields_at( total_values , [fields.index(:datastore_interaction_time)])
-            row = [ model ] + total_values
-            models_loaded = identity_map.all(model).size
-            total_models_loaded += models_loaded
-            row << models_loaded
-            rows << row
-          end
-
-          rows << :separator
-
-          # totals for all models
-          stats_total_values = stats_total.values_at(*fields)
-          self.round_fields_at(stats_total_values , [fields.index(:datastore_interaction_time)])
-          rows << [ "All Models" ] + stats_total_values + [total_models_loaded]
-
-          table = Terminal::Table.new \
-            :rows => rows,
-            :title => "Praxis::Mapper Statistics",
-            :headings => [ "Model", "# Queries", "Records Loaded", "Interactions", "Time(sec)", "Models Loaded" ]
-
-          table.align_column(1, :right)
-          table.align_column(2, :right)
-          table.align_column(3, :right)
-          table.align_column(4, :right)
-          table.align_column(5, :right)
-          self.to_logger "\n#{table.to_s}"
-        end
-
-        def self.round_fields_at(values, indices)
-          indices.each do |idx|
-            values[idx] = "%.3f" % values[idx]
-          end
-        end
-
-        def self.short(identity_map)
-          self.to_logger identity_map.query_statistics.sum_totals.to_s
-        end
-
-        def self.to_logger(message)
-            Praxis::Application.instance.logger.__send__(Plugin.instance.config.stats_log_level, "Praxis::Mapper Statistics: #{message}")
-        end
-      end
-    end
-  end
-end

data/lib/praxis/stats.rb

@@ -1,113 +0,0 @@
-require 'singleton'
-
-require 'harness'
-
-module Praxis
-
-  module Stats
-    include Praxis::PluginConcern
-
-    class Statsd < ::Statsd
-      def initialize(host: '127.0.0.1', port: 8125, prefix: nil, postfix: nil)
-        self.host = host
-        self.port = port
-        self.namespace = prefix if prefix
-        self.postfix = postfix
-        @batch_size = 10
-      end
-    end
-
-    class Plugin < Praxis::Plugin
-      include Singleton
-
-      def initialize
-        @options = {config_file: 'config/stats.yml'}
-      end
-
-      def config_key
-        :stats # 'praxis.stats'
-      end
-
-      def prepare_config!(node)
-        node.attributes do
-          attribute :collector, Hash, default: {type: 'Harness::FakeCollector'} do
-            key :type, String, required: true
-            key :args, Hash
-          end
-          attribute :queue, Hash, default: {type: 'Harness::AsyncQueue' } do
-            key :type, String, required: true
-            key :args, Hash
-          end
-        end
-      end
-
-      def setup!
-        Harness.config.collector = load_type(config.collector)
-        Harness.config.queue = load_type(config.queue)
-      end
-
-      def load_type(hash)
-        type = hash[:type].constantize
-        args = hash[:args]
-        args_hash = case args
-        when Attributor::Hash
-          args.contents.symbolize_keys
-        when Hash
-          args.symbolize_keys
-        when nil
-          {}
-        else
-          raise "unknown args type: #{args.class.name}"
-        end
-        
-        if args_hash.any?        
-          type.new(**args_hash)
-        else
-          type.new
-        end
-
-      end
-
-    end
-
-
-    def self.collector
-      Harness.collector
-    end
-
-    def self.config
-      Harness.config
-    end
-
-    def self.queue
-      Harness.queue
-    end
-
-    def self.count(*args)
-      Harness.count(*args)
-    end
-
-    def self.decrement(*args)
-      Harness.decrement(*args)
-    end
-
-    def self.gauge(*args)
-      Harness.gauge(*args)
-    end
-
-    def self.increment(*args)
-      Harness.increment(*args)
-    end
-
-    def self.time(stat, sample_rate = 1, &block)
-      Harness.time(stat, sample_rate, &block)
-    end
-
-    def self.timing(*args)
-      Harness.timing(*args)
-    end
-
-
-  end
-
-end