pdc 0.1.0

data/lib/pdc/logger.rb

@@ -0,0 +1,19 @@
+require 'logger'
+
+module PDC
+  class << self
+    attr_writer :logger
+
+    def logger
+      @logger ||= ::Logger.new($stdout).tap do |log|
+        log.progname = name
+      end
+    end
+  end
+
+  module Logging
+    def logger
+      PDC.logger
+    end
+  end
+end

data/lib/pdc/resource/attribute_modifier.rb

@@ -0,0 +1,43 @@
+require 'active_support'
+
+module PDC::Resource
+  module AttributeModifier
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # rename an existing attribute `from` to `to`
+      # NOTE from must exist and to must not
+      def attribute_rename(from, to)
+        attribute_modifications << [:rename, from, to]
+      end
+
+      def attribute_modifications
+        @attribute_modifications ||= []
+      end
+    end
+
+    def initialize(attrs = {})
+      super
+      self.class.attribute_modifications.each do |what, *args|
+        case what
+        when :rename
+          apply_attr_rename(*args)
+        else
+          PDC.logger.warn "Invalid attribute transformation #{what}: #{from} #{to}"
+        end
+      end
+
+      yield self if block_given?
+    end
+
+    private
+
+    def apply_attr_rename(from, to)
+      if attributes.key?(from) && !attributes.key?(to)
+        attributes[to] = attributes.delete(from)
+      else
+        PDC.logger.info "rename: not applied for from: #{from}, to: #{to} | #{attributes}"
+      end
+    end
+  end
+end

data/lib/pdc/resource/attribute_store.rb

@@ -0,0 +1,22 @@
+module PDC::Resource
+  class AttributeStore < HashWithIndifferentAccess
+    def to_params
+      each_with_object({}) do |(key, value), parameters|
+        parameters[key] = parse_value(value)
+      end.with_indifferent_access
+    end
+
+    private
+
+      def parse_value(value)
+
+        case
+        when value.is_a?(PDC::Base)           then value.attributes.to_params
+        when value.is_a?(Array)               then value.map { |v| parse_value(v) }
+        else value
+        end
+      end
+
+  end
+end
+

data/lib/pdc/resource/attributes.rb

@@ -0,0 +1,144 @@
+module PDC::Resource
+  module Attributes
+    extend ActiveSupport::Concern
+
+    included do
+      attr_reader :attributes
+      delegate :[], to: :attributes
+    end
+
+    # :nodoc:
+    module ClassMethods
+      # define attributes on Model using
+      # attributes :attribute_name, attribute_name_2 ...
+      #
+      def attributes(*names)
+        return attributes_metadata.keys if names.empty?
+        names.each { |n| attributes_metadata[n] ||= default_metadata }
+        define_methods_in_container(names)
+      end
+
+      def attribute(name, metadata)
+        attr_exists = attributes_metadata.key?(name)
+        attributes_metadata[name] ||= default_metadata
+        attributes_metadata[name].merge!(metadata)
+
+        define_methods_in_container(name) unless attr_exists
+      end
+
+      def attributes_metadata
+        @attributes_metadata ||= HashWithIndifferentAccess.new(primary_key => default_metadata )
+      end
+
+      def attribute_parser(name)
+        # do not add to attributes of the class if not already present
+        metadata = attributes_metadata.fetch(name, default_metadata)
+        metadata[:parser]
+      end
+
+      private
+
+        def default_metadata
+          { parser: ValueParser }
+        end
+
+        def define_methods_in_container(names)
+          instance_method_container.module_eval do
+            Array.wrap(names).each do |name|
+              define_method(name) do
+                attribute(name)
+              end
+            end
+          end
+        end
+
+        # By adding instance methods via an included module, they become
+        # overridable with "super".
+        # see: http://thepugautomatic.com/2013/07/dsom/
+        def instance_method_container
+          unless @instance_method_container
+            @instance_method_container = Module.new
+            include @instance_method_container
+          end
+          @instance_method_container
+        end
+    end # class methods
+
+    def initialize(attributes = {})
+      self.attributes = attributes
+      @uri_template = scoped.uri
+      yield(self) if block_given?
+    end
+
+    def attributes=(new_attributes)
+      @attributes ||= AttributeStore.new
+      use_setters(new_attributes) if new_attributes
+    end
+
+    def []=(name, value)
+      set_attribute(name, value)
+    end
+
+    def inspect
+      "#<#{self.class}(#{@uri_template}) id: #{id.inspect} #{inspect_attributes}>"
+    end
+
+    private
+
+    def use_setters(attributes)
+      attributes.each { |key, value| public_send "#{key}=", value }
+    end
+
+    def method_missing(name, *args, &block)
+      case
+      when attribute?(name)   then attribute(name)
+      when predicate?(name)   then predicate(name)
+      when setter?(name)      then set_attribute(name, args.first)
+      else super
+      end
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      attribute?(name) || predicate?(name) || setter?(name) || super
+    end
+
+    def attribute?(name)
+      attributes.key?(name) || self.class.attributes_metadata.key?(name)
+    end
+
+    def attribute(name)
+      attributes[name]
+    end
+
+    def predicate?(name)
+      name.to_s.end_with?('?')
+    end
+
+    def predicate(name)
+      attribute(depredicate(name)).present?
+    end
+
+    def depredicate(name)
+      name.to_s.chomp('?').to_sym
+    end
+
+    def setter?(name)
+      name.to_s.end_with?('=')
+    end
+
+    def set_attribute(name, value)
+      attr_name = name.to_s.chomp('=')
+      unless attribute?(attr_name)
+        logger.warn "Setting unknown attribute: #{attr_name} #{self.class.name}"
+      end
+      parser = self.class.attribute_parser(attr_name)
+      attributes[attr_name] = parser.parse(value)
+    end
+
+    def inspect_attributes
+      attributes.map { |k, v| "#{k}: #{v.inspect}" }.join(' ')
+    end
+
+  end
+end
+

data/lib/pdc/resource/errors.rb

@@ -0,0 +1,3 @@
+module PDC
+  class MultipleResultsError < Error; end
+end

data/lib/pdc/resource/identity.rb

@@ -0,0 +1,75 @@
+require 'pdc'
+require_relative 'path'
+
+module PDC::Resource
+  # handles id, primary_key and uri of a Resource
+  module Identity
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def primary_key
+        @primary_key ||= default_primary_key
+      end
+
+      def primary_key=(value)
+        @primary_key = value
+      end
+
+      def uri(value = nil)
+        @uri ||= Path.new(value || default_uri).to_s
+      end
+
+      # returns <version>/<resource-name> from the class.name
+      def resource_path
+        @resource_path ||= model_name.collection.sub(%r{^pdc\/}, '').tr('_', '-')
+      end
+
+      private
+
+      def default_uri
+        resource_path + "/(:#{primary_key})"
+      end
+
+      # default pkey for FooBar is foo_bar_id
+      def default_primary_key
+        model_name.foreign_key.to_s
+      end
+    end #  ClassMethods
+
+    def id?
+      attributes[primary_key].present?
+    end
+
+    def id
+      attributes[primary_key]
+    end
+
+    def id=(value)
+      attributes[primary_key] = value if value.present?
+    end
+
+    def hash
+      id.hash
+    end
+
+    def ==(other)
+      other.instance_of?(self.class) && id? && id == other.id
+    end
+    alias :eql? :==
+
+    def as_json(options = nil)
+      attributes.as_json(options)
+    end
+
+    def uri
+      Path.new(self.class.uri.to_s, attributes).expanded
+    end
+
+    private
+      # helper method so that primary_key can be called directly
+      # from an instance
+      def primary_key
+        self.class.primary_key
+      end
+  end
+end

data/lib/pdc/resource/path.rb

@@ -0,0 +1,63 @@
+require 'uri_template'
+
+module PDC::Resource
+  class Path
+
+    def initialize(pattern, params = {})
+      @pattern = pattern
+      @params = params.symbolize_keys
+    end
+
+    def join(other_path)
+      self.class.new File.join(path, other_path.to_s), @params
+    end
+
+    def to_s
+      @pattern
+    end
+
+    def expanded
+      path.to_s
+    end
+
+    def variables
+      @variables ||= uri_template.variables.map(&:to_sym)
+    end
+
+    private
+
+    def path
+      validate_required_params!
+      uri_template.expand(@params).chomp('/')
+    end
+
+    def uri_template
+      @uri_template ||= URITemplate.new(:colon, pattern_with_rfc_style_parens)
+    end
+
+    def pattern_with_rfc_style_parens
+      @pattern.gsub('(', '{').gsub(')', '}')
+    end
+
+    def validate_required_params!
+      return unless missing_required_params.any?
+      missing_params = missing_required_params.join(', ')
+      raise PDC::InvalidPathError, "Missing required params: #{missing_params} in #{@pattern}"
+    end
+
+    def missing_required_params
+      required_params - params_with_values
+    end
+
+    def params_with_values
+      @params.map do |key, value|
+        key if value.present?
+      end.compact
+    end
+
+    def required_params
+      @pattern.scan(/\/:(\w+)/).flatten.map(&:to_sym)
+    end
+  end
+end
+

data/lib/pdc/resource/per_thread_registry.rb

@@ -0,0 +1,54 @@
+# PerThreadRegistry from ActiveSupport 4.0
+
+# This module is used to encapsulate access to thread local variables.
+#
+# Instead of polluting the thread locals namespace:
+#
+#   Thread.current[:connection_handler]
+#
+# you define a class that extends this module:
+#
+#   module ActiveRecord
+#     class RuntimeRegistry
+#       extend ActiveSupport::PerThreadRegistry
+#
+#       attr_accessor :connection_handler
+#     end
+#   end
+#
+# and invoke the declared instance accessors as class methods. So
+#
+#   ActiveRecord::RuntimeRegistry.connection_handler = connection_handler
+#
+# sets a connection handler local to the current thread, and
+#
+#   ActiveRecord::RuntimeRegistry.connection_handler
+#
+# returns a connection handler local to the current thread.
+#
+# This feature is accomplished by instantiating the class and storing the
+# instance as a thread local keyed by the class name. In the example above
+# a key "ActiveRecord::RuntimeRegistry" is stored in <tt>Thread.current</tt>.
+# The class methods proxy to said thread local instance.
+#
+# If the class has an initializer, it must accept no arguments.
+
+module PDC::Resource
+  module PerThreadRegistry
+    def self.extended(object)
+      object.instance_variable_set '@per_thread_registry_key', object.name.freeze
+    end
+    def instance
+      Thread.current[@per_thread_registry_key] ||= new
+    end
+    protected
+      def method_missing(name, *args, &block) # :nodoc:
+        # Caches the method definition as a singleton method of the receiver.
+        #
+        # By letting #delegate handle it, we avoid an enclosure that'll capture args.
+        singleton_class.delegate name, to: :instance
+        send(name, *args, &block)
+      end
+  end
+end
+

data/lib/pdc/resource/relation/finder.rb

@@ -0,0 +1,24 @@
+module PDC::Resource
+  module Finder
+    extend ActiveSupport::Concern
+
+    # returns the contents for the current scope without any pagination as
+    # an +Array+ of +Resources+
+    def contents!
+      return @contents if @contents
+      @contents = result.data.map { |result| new(result) }
+    end
+
+    def find_one!
+      raise(PDC::ResourceNotFound, params) if result.data.empty?
+      raise(PDC::MultipleResultsError, params) if result.data.length > 1
+      @find_one ||= new(result.data.first)
+    end
+
+    private
+    def result
+      @result ||= fetch(clone)
+    end
+  end
+end
+

data/lib/pdc/resource/relation/pagination.rb

@@ -0,0 +1,33 @@
+module PDC::Resource
+  PAGINATION = :pagination
+  PAGINATION_KEYS = [
+    :resource_count,
+    :previous_page,
+    :next_page,
+  ].freeze
+
+  module Pagination
+    extend ActiveSupport::Concern
+
+    PDC::Resource::PAGINATION_KEYS.each do |symbol|
+      define_method(symbol) do
+        result.pagination[symbol]
+      end
+    end
+
+    def each_page
+      return to_enum(:each_page) unless block_given?
+
+      # results are not fetched yet so use the clone for next pages
+      # and create new relation based on the next_page metadata
+
+      relation = clone
+      yield relation
+
+      until (next_page = relation.next_page).nil?
+        relation = self.class.new(klass, uri: next_page)
+        yield relation
+      end
+    end
+  end
+end

data/lib/pdc/resource/relation/query.rb

@@ -0,0 +1,14 @@
+module PDC::Resource
+  module Query
+    extend ActiveSupport::Concern
+
+    def where(conditions)
+      return self if conditions.empty?
+
+      relation = clone
+      relation.params = params.merge(conditions)
+      relation
+    end
+  end
+end
+

data/lib/pdc/resource/relation.rb

@@ -0,0 +1,81 @@
+require 'pdc/resource/relation/query'
+require 'pdc/resource/relation/pagination'
+require 'pdc/resource/relation/finder'
+
+module PDC::Resource
+  class Relation
+    include Enumerable
+    include PDC::Logging
+    include Query
+    include Finder
+    include Pagination
+
+    attr_reader :klass
+    attr_writer :params
+
+    alias :all :to_a
+
+    def initialize(klass, options = {})
+      @klass = klass
+      @options = options
+      @params = {}
+    end
+
+    def params
+      @params.symbolize_keys
+    end
+
+    def uri
+      @options[:uri] || klass.uri
+    end
+
+    # TODO: need to scale this so that mulitle variables in a uri can
+    # be passed - e.g.
+    #    ReleaseVarant.uri is 'v1/release-variant/(:release)/(:id)'
+    #
+    # so find(id, release: 'rel') need to work
+    def find(id, vars = {})
+      raise PDC::ResourceNotFound if id.blank?
+      where(primary_key => id)
+        .where(vars)
+        .find_one!
+    end
+
+    # TODO: handle pagination here
+    def each(&block)
+      return to_enum(:each) unless block_given?
+
+      each_page do |relation|
+        resources = relation.contents!
+        resources.each(&block)
+      end
+    end
+
+    # all! returns all records of the +Resource+
+    # NOTE: use this method for resources with small footprint
+    def all!
+      where(page_size: -1).contents!
+    end
+
+    def count
+      result.pagination[:resource_count]
+    end
+
+    private
+
+      def method_missing(name, *args, &block)
+        # pass anything that relation doesn't know to the klass
+        super unless klass.respond_to? name
+
+        with_scope { klass.send(name, *args, &block) }
+      end
+
+      # Keep hold of current scope while running a method on the class
+      def with_scope
+        previous, klass.current_scope = klass.current_scope, self
+        yield
+      ensure
+        klass.current_scope = previous
+      end
+  end
+end

data/lib/pdc/resource/rest_api.rb

@@ -0,0 +1,34 @@
+module PDC::Resource
+  module RestApi
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :connection, instance_accessor: false
+    end
+
+    module ClassMethods
+      def request(method, path, query = {})
+        PDC.logger.debug '  >>>'.yellow + " : #{path.ai} #{query.ai}"
+        ActiveSupport::Notifications.instrument('request.pdc', method: method) do |payload|
+          response = connection.send(method) do |request|
+            request.url path, query
+          end
+          payload[:url], payload[:status] = response.env.url, response.status
+          PDC::Http::Result.new(response)
+        end
+      end
+
+      def fetch(relation)
+        # TODO: handle v1/release-variant/(:release)/(:variant)
+        # attributes won't contain (:release) and (:variant_id)
+        params = relation.params
+        resource_path = Path.new(relation.uri, params)
+
+        uri = resource_path.expanded
+        query = params.except(*resource_path.variables)
+        request(:get, uri, query)
+      end
+    end # classmethod
+  end
+end
+

data/lib/pdc/resource/scope_registry.rb

@@ -0,0 +1,19 @@
+require_relative 'per_thread_registry'
+
+module PDC::Resource
+  class ScopeRegistry
+    extend PerThreadRegistry
+
+    def initialize
+      @store = Hash.new { |hash, key| hash[key] = {} }
+    end
+
+    def value_for(scope_type, variable_name)
+      @store[scope_type][variable_name]
+    end
+
+    def set_value_for(scope_type, variable_name, value)
+      @store[scope_type][variable_name] = value
+    end
+  end
+end

data/lib/pdc/resource/scopes.rb

@@ -0,0 +1,29 @@
+module PDC::Resource
+  module Scopes
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      delegate :find, :count, :where, :first, :all!, :all, to: :scoped
+
+      def scoped
+        current_scope || Relation.new(self, uri: uri)
+      end
+
+      def scope(name, code)
+        define_singleton_method name, code
+      end
+
+      def current_scope=(value)
+        ScopeRegistry.set_value_for(:current_scope, name, value)
+      end
+
+      def current_scope
+        ScopeRegistry.value_for(:current_scope, name)
+      end
+    end # class methods
+
+    def scoped
+      self.class.scoped
+    end
+  end
+end

data/lib/pdc/resource/value_parser.rb

@@ -0,0 +1,31 @@
+module PDC::Resource
+  # Internal
+  # ValueParser takes in a value and returns the parsed form of the input
+  # e.g. Hash gets converted to OpenStruct so that
+  # foo: {
+  #   bar: {
+  #     too: 'too moo',
+  #     baz: {
+  #       value: 'foobarbaz'
+  #     }
+  #   }
+  # }
+  # can be accessed as foo.bar.too and foo.bar.baz.value
+  class ValueParser
+    class << self
+      def parse(value)
+        case
+        when value.is_a?(Array)     then value.map { |v| parse(v) }
+        when value.is_a?(Hash)      then OpenStruct.new(parse_hash(value))
+        else value
+        end
+      end
+
+      private
+
+        def parse_hash(hash)
+          hash.map { |k, v| [k.to_sym, parse(v)] }.to_h
+        end
+    end
+  end
+end