jsonapionify 0.0.1.pre

data/lib/jsonapionify/structure/objects/resource.rb

@@ -0,0 +1,45 @@
+module JSONAPIonify::Structure
+  module Objects
+    # ResourceObjects appear in a JSON API document to represent resources.
+    class Resource < ResourceIdentifier
+      # The `id` member is not required when the resource object originates at the
+      # client and represents a new resource to be created on the server.
+      must_contain! :id, if: ->(obj) { obj.server? } # an id representing the resource
+
+      # In addition, a resource object **MAY** contain any of these top-level members:
+      may_contain! :attributes, # An AttributesObject representing some of the resource's data.
+                   :relationships, # A RelationshipsObject describing relationships between the resource and other JSON API resources.
+                   :links, # A LinksObject containing links related to the resource.
+                   :meta # A MetaObject containing non-standard meta-information about a resource that can not be represented as an attribute or relationship.
+
+      implements :attributes, as: Attributes
+      implements :relationships, as: Maps::Relationships
+      implements :links, as: Maps::Links
+      implements :meta, as: Meta
+
+      # Note: This spec is agnostic about inflection rules, so the value of `type`
+      # can be either plural or singular. However, the same value should be used
+      # consistently throughout an implementation.
+      def attribute_keys
+        return [] unless self[:attributes]
+        self[:attributes].keys
+      end
+
+      def relationship_keys
+        return [] unless self[:relationships]
+        self[:relationships].keys
+      end
+
+      def relates_to?(other)
+        relationships = self[:relationships]
+        return false unless relationships
+        relationships.any? do |_, resource_identifier|
+          Array.wrap(resource_identifier[:data]).any? do |rel|
+            rel[:id] == other[:id] && rel[:type] == other[:type]
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/jsonapionify/structure/objects/resource_identifier.rb

@@ -0,0 +1,40 @@
+module JSONAPIonify::Structure
+  module Objects
+    class ResourceIdentifier < Base
+      # A resource object **MUST** contain at least the following top-level members:
+      must_contain! :id, :type # Describes ResourceObjects that share common attributes and relationships.
+
+      # Identification
+      # ==============
+      #
+      # The values of the `id` and `type` members **MUST** be strings.
+      type_of! :id, must_be: String
+      type_of! :type, must_be: String
+
+      # The values of `type` members **MUST** adhere to the same constraints as member names.
+      validate!(:type, message: 'is not a valid member name') do |*, value|
+        Helpers::MemberNames.valid? value
+      end
+
+      validate_object!(with: :duplicate_does_not_exist?, message: 'is not unique')
+
+      def duplicate_exists?
+        return false unless parent.is_a?(Array)
+        peers = parent - [self]
+        peers.any? { |peer| same_as? peer }
+      end
+
+      def duplicate_does_not_exist?
+        !duplicate_exists?
+      end
+
+      def same_as?(other)
+        return false unless other.is_a? ResourceIdentifier
+        matches_id   = other.has_key?(:id) && has_key?(:id) && other[:id] == self[:id]
+        matches_type = other[:type] == self[:type]
+        matches_type && matches_id
+      end
+
+    end
+  end
+end

data/lib/jsonapionify/structure/objects/source.rb

@@ -0,0 +1,10 @@
+module JSONAPIonify::Structure
+  module Objects
+    class Source < Base
+      may_contain!(
+        :pointer, # a JSON Pointer [[RFC6901](https://tools.ietf.org/html/rfc6901)] to the associated entity in the request document
+        :parameter # a string indicating which URI query parameter caused the error.
+      )
+    end
+  end
+end

data/lib/jsonapionify/structure/objects/top_level.rb

@@ -0,0 +1,105 @@
+# TopLevelObject
+# ========
+#
+# A JSON object **MUST** be at the root of every JSON API request and response
+# containing data. This object defines a document's "top level".
+module JSONAPIonify::Structure
+  module Objects
+    class TopLevel < Base
+      attr_reader :origin
+
+      default(:jsonapi) { Jsonapi.new version: '1.0' }
+
+      # A document **MUST** contain at least one of:
+      must_contain_one_of!(
+        # **data:** The document's "primary data"
+        :data,
+        # **errors:** An array of errors
+        :errors,
+        # **meta:** a meta object that contains non-standard meta-information.
+        :meta
+      )
+
+      collects :errors, as: Collections::Errors
+      implements :meta, as: Meta
+
+      # The members `data` and `errors` **MUST NOT** coexist in the same document.
+      must_not_coexist! :data, :errors
+
+      # A document **MAY** contain any of these top-level members:
+      may_contain!(
+        # **links:** a links_object related to the primary data.
+        :links,
+        # **included:** an array of resource objects that are related to the primary.
+        :included,
+        # **jsonapi:** an object describing the server's implementation.
+        :jsonapi
+      )
+
+      implements :links, as: Maps::TopLevelLinks
+      collects :included, as: Collections::IncludedResources
+      implements :jsonapi, as: Jsonapi
+      is_resource = ->(obj) { (obj.keys - %i{id type}).present? }
+      collects_or_implements(
+        :data,
+        collects:   Collections::Resources,
+        implements: Resource,
+        if:         ->(obj) {
+          obj.is_a?(Resource) || (obj.is_a?(Hash) && is_resource[obj])
+        })
+      collects_or_implements(
+        :data,
+        collects:   Collections::ResourceIdentifiers,
+        implements: ResourceIdentifier,
+        if:         ->(obj) {
+          obj.is_a?(ResourceIdentifier) || (obj.is_a?(Hash) && !is_resource[obj])
+        })
+
+      # If a document does not contain a top-level `data` key, the `included` member
+      # **MUST NOT** be present either.
+      may_not_exist! :included, without: :data
+
+      # The document's "primary data" is a representation of the resource or collection
+      # of resources targeted by a request.
+      # Primary data **MUST** be either:
+      type_of! :data, must_be: [
+                                 # A single **ResourceObject**
+                                 Resource,
+                                 # A single **ResourceIdentifierObject**
+                                 ResourceIdentifier,
+                                 # Null
+                                 NilClass,
+                                 # A collection of **ResourceObjects**
+                                 Collections::Resources,
+                                 # A collection of **[ResourceIdentifierObjects](resource_identifier_object.html)**
+                                 Collections::ResourceIdentifiers
+                               ]
+
+      def compile(*)
+        compiled        = super
+        compiled_errors = compiled['errors'] || []
+        all_errors      = compiled_errors | errors.as_collection.compile
+        if all_errors.present?
+          self.class.new(
+            errors: all_errors,
+            meta:   {
+              invalid_object: to_hash
+            }
+          ).compile
+        else
+          compiled
+        end
+      end
+
+      def as(origin)
+        copy.tap do |obj|
+          obj.instance_variable_set :@origin, origin
+        end
+      end
+
+      after_initialize do
+        @origin = :server
+      end
+    end
+  end
+end

data/lib/jsonapionify/structure.rb

@@ -0,0 +1,27 @@
+module JSONAPIonify
+  module Structure
+
+    ValidationError = Class.new StandardError
+
+    module Collections
+      extend JSONAPIonify::Autoload
+      autoload_all 'structure/collections'
+    end
+
+    module Maps
+      extend JSONAPIonify::Autoload
+      autoload_all 'structure/maps'
+    end
+
+    module Objects
+      include Maps
+      extend JSONAPIonify::Autoload
+      autoload_all 'structure/objects'
+    end
+
+    module Helpers
+      extend JSONAPIonify::Autoload
+      autoload_all 'structure/helpers'
+    end
+  end
+end

data/lib/jsonapionify/types/array_type.rb

@@ -0,0 +1,32 @@
+module JSONAPIonify::Types
+  class ArrayType < BaseType
+
+    after_initialize do
+      unless options[:of].is_a? BaseType
+        raise TypeError, "#{options[:of]} is not a valid JSON type."
+      end
+    end
+
+    def load(value)
+      super unless options[:of]
+      value.map do |item|
+        options[:of].load(item)
+      end
+    end
+
+    def dump(value)
+      super unless options[:of]
+      value.map do |item|
+        options[:of].dump(item)
+      end
+    end
+
+    def sample(field_name)
+      field_name = field_name.to_s.singularize.to_sym
+      3.times.map do
+        (options[:of] || StringType.new).sample(field_name)
+      end
+    end
+
+  end
+end

data/lib/jsonapionify/types/boolean_type.rb

@@ -0,0 +1,22 @@
+module JSONAPIonify::Types
+  class BooleanType < BaseType
+
+    def load(value)
+
+    end
+    
+    def dump(value)
+      case value
+      when true, false
+        value
+      else
+        raise TypeError, "#{value} is not a valid JSON #{name}."
+      end
+    end
+
+    def sample(*)
+      [true, false].sample
+    end
+
+  end
+end

data/lib/jsonapionify/types/date_string_type.rb

@@ -0,0 +1,28 @@
+require 'faker'
+
+module JSONAPIonify::Types
+  class DateStringType < BaseType
+    def load(value)
+      Date.parse value
+    end
+
+    def dump(value)
+      case value
+      when Date
+        Oj.dump(value.to_date)
+      else
+        raise TypeError, "#{value} is not a valid JSON #{name}."
+      end
+    end
+
+    def sample(field_name)
+      field_name = field_name.to_s
+      if field_name.to_s.end_with?('ed_at') || field_name.include?('start')
+        Faker::Date.backward
+      elsif field_name.include?('end')
+        Faker::Date.forward
+      end
+    end
+
+  end
+end

data/lib/jsonapionify/types/float_type.rb

@@ -0,0 +1,8 @@
+module JSONAPIonify::Types
+  class FloatType < BaseType
+
+    def sample(*)
+      rand(0.0..201.42).round(2)
+    end
+  end
+end

data/lib/jsonapionify/types/integer_type.rb

@@ -0,0 +1,9 @@
+module JSONAPIonify::Types
+  class IntegerType < BaseType
+
+    def sample(*)
+      rand(1..123)
+    end
+
+  end
+end

data/lib/jsonapionify/types/object_type.rb

@@ -0,0 +1,22 @@
+require 'active_support/core_ext/hash/keys'
+
+module JSONAPIonify::Types
+  class ObjectType < BaseType
+
+    def load(value)
+      super(value).deep_symbolize_keys
+    end
+
+    def dump(value)
+      super(value.deep_stringify_keys)
+    end
+
+    def sample(field_name)
+      field_name = field_name.to_s.singularize.to_sym
+      %i{foo bar baz}.each_with_object({}) do |k, h|
+        h[k] = StringType.new.sample(field_name)
+      end
+    end
+
+  end
+end

data/lib/jsonapionify/types/string_type.rb

@@ -0,0 +1,66 @@
+require 'faker'
+
+module JSONAPIonify::Types
+  class StringType < BaseType
+    class StringSampler
+      delegate *Faker::Address.methods(false), to: Faker::Address
+      delegate *Faker::Code.methods(false), to: Faker::Code
+      delegate :suffix, :catch_phrase, :bs, :ein, :duns_number, :logo, to: Faker::Company
+      alias_method :slogan, :catch_phrase
+      delegate :name, to: Faker::Company, prefix: :company
+      alias_method :company, :company_name
+      delegate :credit_card, to: Faker::Finance, prefix: :company
+      delegate *Faker::Internet.methods(false), to: Faker::Internet
+      delegate :first_name, :last_name, :prefix, :suffix, :title, to: Faker::Name
+      delegate *Faker::PhoneNumber.methods(false), to: Faker::PhoneNumber
+      alias_method :phone, :phone_number
+      alias_method :mobile, :cell_phone
+      alias_method :cell, :cell_phone
+      delegate *Faker::Commerce.methods(false), to: Faker::Commerce
+      delegate *Faker::Avatar.methods(false), to: Faker::Avatar, prefix: :avatar
+      alias_method :avatar_url, :avatar_image
+      alias_method :profile_image, :avatar_image
+      alias_method :profile_pic, :avatar_image
+      delegate :birthday, to: Faker::Date
+
+      def initialize(field_name)
+        @field_name = field_name
+      end
+
+      def hacker_speak
+        Faker::Hacker.say_something_smart
+      end
+
+      def full_name
+        Faker::Name.name
+      end
+
+      def domain
+        [Faker::Internet.domain_word, Faker::Internet.domain_suffix].join '.'
+      end
+
+      def description
+        Faker::Lorem.paragraph
+      end
+
+      alias_method :body, :description
+      alias_method :content, :description
+      alias_method :prompt, :description
+
+      def value
+        if self.class.instance_methods(false).include?(@field_name)
+          public_send(@field_name)
+        elsif (field = self.class.instance_methods(false).find { |m| @field_name.to_s.include? m.to_s })
+          public_send(field)
+        else
+          Faker::Lorem.word
+        end
+      end
+
+    end
+
+    def sample(field_name)
+      StringSampler.new(field_name).value
+    end
+  end
+end

data/lib/jsonapionify/types/time_string_type.rb

@@ -0,0 +1,28 @@
+require 'faker'
+
+module JSONAPIonify::Types
+  class TimeStringType < BaseType
+    def load(value)
+      Time.parse value
+    end
+
+    def dump(value)
+      case value
+      when Time
+        JSON.dump(value.to_time)
+      else
+        raise TypeError, "#{value} is not a valid JSON #{name}."
+      end
+    end
+
+    def sample(field_name)
+      field_name = field_name.to_s
+      if field_name.to_s.end_with?('ed_at') || field_name.include?('start')
+        Faker::Time.backward
+      elsif field_name.include?('end')
+        Faker::Time.forward
+      end
+    end
+
+  end
+end

data/lib/jsonapionify/types.rb

@@ -0,0 +1,49 @@
+require 'oj'
+
+module JSONAPIonify::Types
+  extend JSONAPIonify::Autoload
+  autoload_all
+
+  def types
+    DefinitionFinder
+  end
+
+  module DefinitionFinder
+    def self.method_missing(m, *args)
+      JSONAPIonify::Types.const_get("#{m}Type", false).new(*args)
+    rescue NameError
+      raise TypeError, "#{m} is not a valid JSON type."
+    end
+  end
+
+  class BaseType
+    include JSONAPIonify::Callbacks
+    define_callbacks :initialize
+
+    def name
+      self.class.name.split('::').last.chomp('Type')
+    end
+
+    attr_reader :options
+
+    def initialize(**options)
+      run_callbacks :initialize do
+        @options = options
+      end
+      freeze
+    end
+
+    def load(non_ruby)
+      non_ruby
+    end
+
+    def dump(ruby)
+      JSON.load JSON.dump ruby
+    end
+
+    def verify(non_ruby)
+      dump(load(non_ruby)) == non_ruby
+    end
+
+  end
+end

data/lib/jsonapionify/unstrict_proc.rb

@@ -0,0 +1,28 @@
+module JSONAPIonify
+  module UnstrictProc
+    refine Proc do
+      def unstrict
+        return self unless lambda?
+        req_count = required_parameters.count
+        Proc.new do |*arguments|
+          if req_count > arguments.count
+            (req_count - arguments.count).times { arguments << nil }
+          elsif req_count < arguments.count
+            arguments = req_count == 0 ? [] : arguments[0..(req_count - 1)]
+          end
+          call(*arguments)
+        end
+      end
+
+      private
+
+      def parameters_hash
+        parameters.each_with_object({}) { |(k, v), h| (h[k] ||= []) << v }
+      end
+
+      def required_parameters
+        parameters_hash[:req] || []
+      end
+    end
+  end
+end

data/lib/jsonapionify/version.rb

@@ -0,0 +1,3 @@
+module JSONAPIonify
+  VERSION = "0.0.1.pre"
+end

data/lib/jsonapionify.rb

@@ -0,0 +1,37 @@
+require 'pry' rescue nil
+require 'core_ext/boolean'
+require "active_support/core_ext/string/inflections"
+require "active_support/core_ext/hash/keys"
+require 'active_support/cache'
+require 'jsonapionify/autoload'
+
+module JSONAPIonify
+  autoload :VERSION, 'jsonapi-objects/version'
+  extend JSONAPIonify::Autoload
+  autoload_all 'jsonapionify'
+
+  def self.path
+    __dir__
+  end
+
+  def self.parse(hash)
+    hash = JSON.parse(hash) if hash.is_a? String
+    Structure::Objects::TopLevel.from_hash(hash)
+  end
+
+  def self.new_object
+    Structure::Objects::TopLevel.new
+  end
+
+  def self.cache(store, *args)
+    self.cache_store = ActiveSupport::Cache.lookup_store(store, *args)
+  end
+
+  def self.cache_store=(store)
+    @cache_store = store
+  end
+
+  def self.cache_store
+    @cache_store ||= ActiveSupport::Cache.lookup_store :null_store
+  end
+end