ncore 1.0.0

data/lib/ncore/identity.rb

@@ -0,0 +1,26 @@
+module NCore
+  module Identity
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def class_name
+        self.name.split('::')[-1]
+      end
+
+      def module_name
+        self.name.split('::')[0..-2].join('::')
+      end
+
+      def attrib_name
+        class_name.underscore
+      end
+      alias :json_root :attrib_name
+    end
+
+
+    def json_root
+      self.class.json_root
+    end
+
+  end
+end

data/lib/ncore/lifecycle.rb

@@ -0,0 +1,36 @@
+module NCore
+  module Lifecycle
+
+    def errors?
+      @errors.any?
+    end
+
+    def valid?
+      @errors.none?
+    end
+
+
+    def save(update_params={})
+      if id.present?
+        if respond_to? :update, true
+          update(update_params)
+        else
+          raise self.class.parent::Error, "Updating #{self.class.name} objects is not supported."
+        end
+      else
+        if respond_to? :create, true
+          create(update_params)
+        else
+          raise self.class.parent::Error, "Creating #{self.class.name} objects is not supported."
+        end
+      end
+    end
+    alias :update_attributes :save
+
+    def save!(update_params={})
+      save(update_params) || raise(self.class.parent::RecordInvalid, self)
+    end
+    alias :update_attributes! :save!
+
+  end
+end

data/lib/ncore/methods/all.rb

@@ -0,0 +1,30 @@
+module NCore
+  module All
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def all(params={}, api_creds=nil)
+        parsed, creds = request(:get, url, api_creds, params)
+        if parsed[:errors].any?
+          raise parent::QueryError, parsed[:errors]
+        end
+        Collection.new.tap do |coll|
+          coll.metadata = parsed[:metadata]
+          parsed[:data].each do |hash|
+            if key = hash[:object]
+              coll << discover_class(key, self).new(hash.merge(metadata: parsed[:metadata]), creds)
+            else
+              coll << new(hash.merge(metadata: parsed[:metadata]), creds)
+            end
+          end
+        end
+      end
+
+      def first(params={}, api_creds=nil)
+        params = params.with_indifferent_access.merge(max_results: 1)
+        all(params, api_creds).first
+      end
+    end
+
+  end
+end

data/lib/ncore/methods/build.rb

@@ -0,0 +1,16 @@
+module NCore
+  module Build
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def build(params={}, api_creds=nil)
+        parsed, creds = request(:get, url+'/new', api_creds, params)
+        if parsed[:errors].any?
+          raise parent::QueryError, parsed[:errors]
+        end
+        new(parsed, creds)
+      end
+    end
+
+  end
+end

data/lib/ncore/methods/count.rb

@@ -0,0 +1,13 @@
+module NCore
+  module Count
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def count(params={}, api_creds=nil)
+        parsed, _ = request(:get, "#{url}/count", api_creds, params)
+        parsed[:data][:count]
+      end
+    end
+
+  end
+end

data/lib/ncore/methods/create.rb

@@ -0,0 +1,33 @@
+module NCore
+  module Create
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def create!(attribs={}, api_creds=nil)
+        obj = create(attribs, api_creds)
+        if obj.errors.any?
+          raise parent::RecordInvalid, obj
+        end
+        obj
+      end
+
+      # always returns a new object; check .errors? or .valid? to see how it went
+      def create(attribs={}, api_creds=nil)
+        params = {json_root => attribs}
+        parsed, creds = request(:post, url, api_creds, params)
+        new(attribs, creds).send(:load, parsed)
+      end
+    end
+
+    private
+
+    def create(attribs={})
+      params = {json_root => attribs}
+      parsed, @api_creds = request(:post, self.class.url, api_creds, params)
+      load(data: attribs) if parsed[:errors].any?
+      load(parsed)
+      errors.empty? ? self : false
+    end
+
+  end
+end

data/lib/ncore/methods/delete.rb

@@ -0,0 +1,19 @@
+module NCore
+  module Delete
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def delete(id, params={}, api_creds=nil)
+        obj = new({id: id}, api_creds)
+        obj.delete(params) || raise(parent::RecordInvalid, obj)
+      end
+    end
+
+    def delete(params={})
+      parsed, @api_creds = request(:delete, url, api_creds, params)
+      load(parsed)
+      errors.empty? ? self : false
+    end
+
+  end
+end

data/lib/ncore/methods/delete_single.rb

@@ -0,0 +1,19 @@
+module NCore
+  module DeleteSingle
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def delete(params={}, api_creds=nil)
+        obj = new({}, api_creds)
+        obj.delete(params) || raise(parent::RecordInvalid, obj)
+      end
+    end
+
+    def delete(params={})
+      parsed, @api_creds = request(:delete, url, api_creds, params)
+      load(parsed)
+      errors.empty? ? self : false
+    end
+
+  end
+end

data/lib/ncore/methods/find.rb

@@ -0,0 +1,26 @@
+module NCore
+  module Find
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def find(id, params={}, api_creds=nil)
+        o = new({id: id}, api_creds)
+        o.reload(params)
+      end
+
+      def retrieve(id, params={}, api_creds=nil)
+        find id, params, api_creds
+      rescue parent::RecordNotFound
+        false
+      end
+    end
+
+    def reload(find_params={})
+      return if id.blank?
+      parsed, @api_creds = request(:get, url, api_creds, find_params)
+      @attribs = {}.with_indifferent_access
+      load(parsed)
+    end
+
+  end
+end

data/lib/ncore/methods/find_single.rb

@@ -0,0 +1,34 @@
+module NCore
+  module FindSingle
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def find(params={}, api_creds=nil)
+        parsed, creds = request(:get, url, api_creds, params)
+        if parsed[:errors].any?
+          raise parent::QueryError, parsed[:errors]
+        end
+        new(parsed, creds)
+      end
+
+      def retrieve(params={}, api_creds=nil)
+        find params, api_creds
+      rescue parent::RecordNotFound
+        false
+      end
+    end
+
+    def id
+      'singleton'
+    end
+
+    private
+
+    def reload(find_params={})
+      parsed, @api_creds = request(:get, url, api_creds, find_params)
+      @attribs = {}.with_indifferent_access
+      load(parsed)
+    end
+
+  end
+end

data/lib/ncore/methods/update.rb

@@ -0,0 +1,29 @@
+module NCore
+  module Update
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def update!(id, attribs, api_creds=nil)
+        obj = new({id: id}, api_creds)
+        obj.save!(attribs)
+      end
+
+      def update(id, attribs, api_creds=nil)
+        obj = new({id: id}, api_creds)
+        obj.save(attribs)
+      end
+    end
+
+
+    private
+
+    def update(attribs={})
+      params = {json_root => attribs}
+      parsed, @api_creds = request(:put, url, api_creds, params)
+      load(data: attribs) if parsed[:errors].any?
+      load(parsed)
+      errors.empty? ? self : false
+    end
+
+  end
+end

data/lib/ncore/rails/active_model.rb

@@ -0,0 +1,44 @@
+require 'active_model'
+
+module NCore
+  module ActiveModel
+    extend ActiveSupport::Concern
+
+    included do
+      include ::ActiveModel::Conversion
+      extend  ::ActiveModel::Translation
+      alias :errors :errors_for_actionpack
+    end
+
+    if defined?(Rails)
+      def logger
+        Rails.logger
+      end
+    end
+
+    def new_record?
+      !id
+    end
+
+    def persisted?
+      !new_record?
+    end
+
+    def destroy(*args)
+      delete(*args)
+    end
+
+    # actionpack 4 requires a more robust Errors object
+    def errors_for_actionpack
+      e0 = ::ActiveModel::Errors.new(self)
+      @errors.each do |e|
+        e0.add :base, e
+      end
+      e0
+    end
+
+  end
+
+  Base.send :include, ActiveModel
+  SingletonBase.send :include, ActiveModel
+end

data/lib/ncore/rails/log_subscriber.rb

@@ -0,0 +1,116 @@
+module NCore
+  module LogSubscriber
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :runtime_variable, instance_accessor: false
+
+      # make :request show up in parent::LogSubscriber.new.public_methods(false)
+      define_method :request do |event|
+        log_request event
+      end
+    end
+
+    module ClassMethods
+      def runtime=(value)
+        Thread.current[runtime_variable] = value
+      end
+
+      def runtime
+        Thread.current[runtime_variable] ||= 0
+      end
+
+      def reset_runtime
+        rt, self.runtime = runtime, 0
+        rt
+      end
+    end
+
+    def log_request(event)
+      self.class.runtime += event.duration
+
+      env = event.payload
+      url = env[:url].to_s
+      http_method = env[:method].to_s.upcase
+      http_status = env[:status] || -1
+
+      msg = "%s %s" % [http_method, url]
+      res = " -> %d (%.1f ms)" % [http_status, event.duration]
+
+      msg = color(msg, ActiveSupport::LogSubscriber::YELLOW, false)
+      if (200..299).include? http_status
+        res = color(res, ActiveSupport::LogSubscriber::GREEN, true)
+      else
+        res = color(res, ActiveSupport::LogSubscriber::RED, true)
+      end
+
+      if (200..299).include? http_status
+        debug "  #{msg}"
+        debug "  #{res}"
+      else
+        error "  #{msg}"
+        error "  #{res}"
+      end
+    end
+
+  end
+
+  # Extends ActionController's logging system so as to include Api
+  #   cumulative runtime at the end of each action's log entry.
+  # See ActiveRecord::Railties::ControllerRuntime for reference
+  module ControllerRuntime
+    extend ActiveSupport::Concern
+
+    protected
+
+    mattr_accessor :api_runtime_list
+    self.api_runtime_list = []
+
+    def process_action(action, *args)
+      api_runtime_list.each do |arl|
+        arl[:log_sub].reset_runtime
+        arl[:rt] = 0
+      end
+      super
+    end
+
+    def cleanup_view_runtime
+      rt_before_render = {}
+      rt_after_render = {}
+      api_runtime_list.each do |arl|
+        rt_before_render[arl[:title]] = arl[:log_sub].reset_runtime
+      end
+      runtime = super
+      api_runtime_list.each do |arl|
+        rt_after_render[arl[:title]] = arl[:log_sub].reset_runtime
+        arl[:rt] = rt_before_render[arl[:title]] + rt_after_render[arl[:title]]
+      end
+      runtime - rt_after_render.values.sum
+    end
+
+    def append_info_to_payload(payload)
+      super
+      payload[:api_runtime] = {}
+      api_runtime_list.each do |arl|
+        payload[:api_runtime][arl[:title]] = arl[:rt] + arl[:log_sub].reset_runtime
+      end
+    end
+
+
+    module ClassMethods
+
+      def log_process_action(payload)
+        messages, rt_set = super, payload[:api_runtime]
+        rt_set.each do |title, rt|
+          messages << ("#{title}: %.1fms" % rt.to_f) if rt && rt > 0
+        end if rt_set
+        messages
+      end
+
+      def register_api_runtime(log_sub, title)
+        ControllerRuntime.api_runtime_list += [{log_sub: log_sub, title: title, rt: 0}]
+      end
+    end
+
+  end
+end