json_api_ruby 0.0.1.alpha

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f137dccac6caa31e15ca4519ed3b6a9e45682739
+  data.tar.gz: 5256e906efe7899bfacd0c6916620bdc066d8dc6
+SHA512:
+  metadata.gz: 76ce05324913fb8100783b4a3f274c98c1e4a8afa6d2ec0fc90db58f8d1aac39379012de2bd6dd0f178343d11f805a867fb9b1a715df3021ea76c5d50f62ba83
+  data.tar.gz: 1bd8c66e4ebb6c7ddf1f0137f90fe5050b08c5e81d0b4c9503f42cf095fc2124d94b86ec7b44954a4c888634aa37294e207c2d3b55342060ee77e4074edca2d7

data/.gitignore

@@ -0,0 +1 @@
+pkg

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in magensa.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,92 @@
+PATH
+  remote: .
+  specs:
+    json_api (0.0.1.beta)
+      activesupport
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.2.5)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    byebug (8.2.1)
+    coderay (1.1.0)
+    diff-lcs (1.2.5)
+    ffi (1.9.10)
+    formatador (0.2.5)
+    guard (2.13.0)
+      formatador (>= 0.2.4)
+      listen (>= 2.7, <= 4.0)
+      lumberjack (~> 1.0)
+      nenv (~> 0.1)
+      notiffany (~> 0.0)
+      pry (>= 0.9.12)
+      shellany (~> 0.0)
+      thor (>= 0.18.1)
+    guard-compat (1.2.1)
+    guard-rspec (4.6.4)
+      guard (~> 2.1)
+      guard-compat (~> 1.1)
+      rspec (>= 2.99.0, < 4.0)
+    i18n (0.7.0)
+    json (1.8.3)
+    listen (3.0.5)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+    lumberjack (1.0.10)
+    method_source (0.8.2)
+    minitest (5.8.3)
+    nenv (0.2.0)
+    notiffany (0.0.8)
+      nenv (~> 0.1)
+      shellany (~> 0.0)
+    pry (0.10.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    pry-byebug (3.3.0)
+      byebug (~> 8.0)
+      pry (~> 0.10)
+    rb-fsevent (0.9.7)
+    rb-inotify (0.9.5)
+      ffi (>= 0.5.0)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.1)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-its (1.2.0)
+      rspec-core (>= 3.0.0)
+      rspec-expectations (>= 3.0.0)
+    rspec-mocks (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
+    shellany (0.0.1)
+    slop (3.6.0)
+    thor (0.19.1)
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  guard-rspec
+  json_api!
+  pry-byebug
+  rspec (~> 3)
+  rspec-its
+
+BUNDLED WITH
+   1.10.6

data/Guardfile

@@ -0,0 +1,69 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+directories %w(lib spec).select{|d| Dir.exists?(d) ? d : UI.warning("Directory #{d} does not exist")}
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separately)
+#  * 'just' rspec: 'rspec'
+
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # Feel free to open issues for suggestions and improvements
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+
+  # Rails files
+  rails = dsl.rails(view_extensions: %w(erb haml slim))
+  dsl.watch_spec_files_for(rails.app_files)
+  dsl.watch_spec_files_for(rails.views)
+
+  watch(rails.controllers) do |m|
+    [
+      rspec.spec.("routing/#{m[1]}_routing"),
+      rspec.spec.("controllers/#{m[1]}_controller"),
+      rspec.spec.("acceptance/#{m[1]}")
+    ]
+  end
+
+  # Rails config changes
+  watch(rails.spec_helper)     { rspec.spec_dir }
+  watch(rails.routes)          { "#{rspec.spec_dir}/routing" }
+  watch(rails.app_controller)  { "#{rspec.spec_dir}/controllers" }
+
+  # Capybara features specs
+  watch(rails.view_dirs)     { |m| rspec.spec.("features/#{m[1]}") }
+  watch(rails.layouts)       { |m| rspec.spec.("features/#{m[1]}") }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$}) do |m|
+    Dir[File.join("**/#{m[1]}.feature")][0] || "spec/acceptance"
+  end
+end

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/json_api_ruby.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'json_api_ruby/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "json_api_ruby"
+  spec.version       = JsonApi::VERSION
+  spec.authors       = ["Tracey Eubanks"]
+  spec.email         = ["tracey@bypassmobile.com"]
+  spec.description   = %q{Create JSON API resources when you don't have Rails 4+ available}
+  spec.summary       = %q{Create JSON API resources when you don't have Rails 4+ available}
+  spec.homepage      = "https://github.com/teubanks/jsonapi_ruby"
+  spec.license       = "Free For All"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport", "~> 3"
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rspec", "~> 3"
+  spec.add_development_dependency "rspec-its", "~> 1"
+  spec.add_development_dependency "pry-byebug", "~> 3"
+  spec.add_development_dependency "guard-rspec", "~> 4"
+end

data/lib/json_api_ruby/configuration.rb

@@ -0,0 +1,15 @@
+module JsonApi
+  class Configuration
+    attr_reader :base_url
+
+    def initialize
+      @base_url = 'http://localhost:3000'
+    end
+  end
+
+  class << self
+    attr_accessor :configuration
+  end
+
+  @configuration = Configuration.new
+end

data/lib/json_api_ruby/error_resource.rb

@@ -0,0 +1,11 @@
+class ErrorResource
+  attr_reader :object
+
+  def initialize(object)
+    @object = object
+  end
+
+  def to_hash
+    { 'detail' => object }
+  end
+end

data/lib/json_api_ruby/exceptions.rb

@@ -0,0 +1,3 @@
+module JsonApi
+  ResourceNotFound = Class.new(StandardError)
+end

data/lib/json_api_ruby/resource.rb

@@ -0,0 +1,55 @@
+require_relative 'resources/base'
+require_relative 'resources/relationships'
+require_relative 'resources/dsl'
+
+module JsonApi
+  class Resource
+    include Resources::Base
+    extend Resources::DSL
+
+    def self.inherited(subclass)
+      subclass.send(:id_field, :id)
+    end
+
+    # Can be set using `id_field` in the created resource class like so:
+    #
+    # class ObjectResource < JsonApi::Resource
+    #   id_field :uuid
+    # end
+    #
+    # defaults to :id
+    def id
+      object.public_send(self.class._id_field).to_s
+    end
+
+    # Can be overridden in a subclass
+    def type
+      _model.class.to_s.underscore.pluralize
+    end
+
+    # Makes the underlying object available to subclasses so we can do things
+    # like
+    #
+    #   class PersonResource < JsonApi::Resource
+    #     attribute :email
+    #     attribute :full_name
+    #
+    #     def full_name
+    #       "#{object.first_name} #{object.last_name}"
+    #     end
+    #   end
+    def object
+      _model
+    end
+
+    attr_accessor :_model
+
+    attr_reader :includes
+
+    def initialize(model, options={})
+      @_model = model
+      @includes = options.fetch(:include, []).map(&:to_s)
+      build_object_graph # base module method
+    end
+  end
+end

data/lib/json_api_ruby/resources/base.rb

@@ -0,0 +1,61 @@
+require_relative 'discovery'
+module JsonApi
+  module Resources
+
+    module Base
+      attr_reader :relationships
+      def to_hash(options={})
+        options.symbolize_keys
+
+        resource_hash = identifier_hash
+        resource_hash['attributes'] = attributes_hash
+
+        relationships.each do |relationship|
+          resource_hash['relationships'] ||= {}
+          resource_hash['relationships'][relationship.name] = relationship.to_hash
+        end
+
+        resource_hash['links'] = links_hash
+        resource_hash
+      end
+
+      # Very basic. Eventually this will need to parse things like
+      # "article.comments" and "article-comments", so, leaving the method here
+      # but only supporting the most basic of things
+      def parse_for_includes(includes)
+        Array(includes).map {|inc| inc.to_s }
+      end
+
+      def identifier_hash
+        { 'id' =>  self.id, 'type' =>  self.type }
+      end
+
+      def links_hash
+        { 'self' => JsonApi.configuration.base_url + self_link_path }
+      end
+
+      def self_link_path
+        "/#{self.type}/#{self.id}"
+      end
+
+      def attributes_hash
+        attrs = {}
+        self.class.fields.each do |attr|
+          attrs[attr.to_s] = send(attr)
+        end
+        attrs
+      end
+
+      # Builds relationship resource classes
+      def build_object_graph
+        @relationships ||= []
+        Array(self.class.relationships).each do |relationship|
+          included = includes.include?(relationship.name)
+          relationship.build_resources({parent_resource: self, included: included})
+          @relationships << relationship
+        end
+      end
+    end
+
+  end
+end

data/lib/json_api_ruby/resources/discovery.rb

@@ -0,0 +1,40 @@
+module JsonApi
+  module Resources
+    class Discovery
+      def self.resource_for_name(model, options={})
+        namespace = options.fetch(:namespace, nil)
+        klass = options.fetch(:resource_class, nil)
+        parent = options.fetch(:parent_resource, nil)
+
+        if klass.blank?
+          # discover it
+          klass = resource_class(model.class.to_s.underscore, namespace: namespace, parent: parent)
+        end
+
+        Object.const_get(klass)
+      rescue NameError
+        fail ::JsonApi::ResourceNotFound.new("Could not find resource class `#{klass}'")
+      end
+
+      def self.resource_class(model_name, namespace:, parent:)
+        if namespace
+          klass = [
+            namespace.to_s.underscore,
+            "#{model_name.to_s.underscore}_resource"
+          ].join('/').classify
+        else
+          klass = resource_path(model_name, parent).join.classify
+        end
+        klass
+      end
+
+      def self.resource_path(model_name, parent)
+        current_namespace = parent.class.to_s.underscore.split('/')
+        current_namespace.pop
+        current_namespace << '/' if current_namespace.present?
+        current_namespace << "#{model_name.to_s}_resource"
+        current_namespace
+      end
+    end
+  end
+end

data/lib/json_api_ruby/resources/dsl.rb

@@ -0,0 +1,54 @@
+module JsonApi
+  module Resources
+    module DSL
+      attr :_id_field
+      attr :fields
+      attr :relationships
+
+      def attributes(*attrs)
+        attrs.each do |attr|
+          attribute(attr)
+        end
+      end
+
+      def attribute(attr)
+        @fields ||= []
+        @fields << attr
+        create_accessor_methods(attr)
+      end
+
+      def has_one(object_name, options={})
+        add_relationship(object_name, :one, options)
+      end
+
+      def has_many(object_name, options={})
+        add_relationship(object_name, :many, options)
+      end
+
+      def id_field(key)
+        @_id_field = key
+      end
+
+      private
+      def add_relationship(object_name, cardinality, options)
+        @relationships ||= []
+        if cardinality == :one
+          @relationships << ToOneRelationship.new(object_name, options)
+        else
+          @relationships << ToManyRelationship.new(object_name, options)
+        end
+        create_accessor_methods(object_name)
+      end
+
+      def create_accessor_methods(attr)
+        define_method(attr) do
+          object.public_send(attr)
+        end unless method_defined?(attr)
+
+        define_method("#{attr}=") do |value|
+          object.public_send("#{attr}=", value)
+        end unless method_defined?("#{attr}=")
+      end
+    end
+  end
+end

data/lib/json_api_ruby/resources/relationships.rb

@@ -0,0 +1,106 @@
+module JsonApi
+  module Resources
+
+    class Relationships
+      # The name of this relationship.
+      #   This name comes from the resource object that defines the
+      #   relationship. Example:
+      #     class ArticleResource < JsonApi::Resource
+      #       has_one :author # this is the name of this relationship
+      #     end
+      attr_reader :name
+
+      # The resource object that "owns" this relationship
+      #
+      # Example:
+      #   class ArticleResource < JsonApi::Resource
+      #     has_one :author
+      #   end
+      #
+      # `ArticleResource` is the parent of the author object
+      attr_reader :parent
+
+      # Determines whether the `data` attribute should be filled out and
+      # included
+      attr_reader :included
+
+      # The resource object that represents this relationship
+      attr_reader :resources
+
+      attr_reader :parent_model
+
+      def initialize(name, options)
+        @name = name.to_s
+        @resources = []
+      end
+
+      def to_hash
+        return_hash = links
+        return_hash.merge!(data) if included?
+        return_hash
+      end
+
+      def build_resources(options)
+        @parent = options.fetch(:parent_resource)
+        @parent_model = parent._model
+        @included = options.fetch(:included, false)
+      end
+
+      def included?
+        included == true
+      end
+
+      def links
+        {
+          'links' => {
+            'self' => JsonApi.configuration.base_url + parent.self_link_path + "/relationships/#{name}",
+            'related' => JsonApi.configuration.base_url + parent.self_link_path + "/#{name}"
+          }
+        }
+      end
+    end
+
+    # convenience classes
+    class ToOneRelationship < Relationships
+      def data(options={})
+        identifier_hash = resource_object.identifier_hash if resource_object
+        {'data' => Hash(identifier_hash)}
+      end
+
+      def build_resources(options)
+        super
+        return unless included?
+        resource_model = parent_model.send(name)
+        return if resource_model.blank?
+        resource_class = Discovery.resource_for_name(resource_model, options.merge(parent_resource: parent))
+        @resources << resource_class.new(resource_model)
+      end
+
+      def resource_object
+        @resources.first
+      end
+    end
+
+    class ToManyRelationship < Relationships
+      def data(options={})
+        data = resource_objects.map do |object|
+          object.identifier_hash
+        end
+        {'data' => data}
+      end
+
+      def build_resources(options)
+        super
+        return unless included?
+        parent_model.send(name).each do |resource_model|
+          resource_class = Discovery.resource_for_name(resource_model, options.merge(parent_resource: parent))
+          @resources << resource_class.new(resource_model)
+        end
+      end
+
+      def resource_objects
+        @resources
+      end
+    end
+  end
+end

data/lib/json_api_ruby/serializer.rb

@@ -0,0 +1,100 @@
+module JsonApi
+  extend self
+
+  def serialize_errors(*errors)
+    resource_hashes = errors.flatten.map do |error|
+      ErrorResource.new(error).to_hash
+    end
+    { errors: resource_hashes }
+  end
+
+  def serialize(object, options = {})
+    options.stringify_keys!
+    # assume it's a collection
+    if object.present? && object.respond_to?(:to_a)
+      serializer = CollectionSerializer.new(object, options)
+    else
+      serializer = Serializer.new(object, options)
+    end
+    serializer.to_hash
+  end
+
+  class Serializer
+    def initialize(object, options)
+      @meta         = options.fetch('meta', Hash.new).stringify_keys
+      @object       = object
+      @includes     = options.fetch('include', [])
+      resource_name = "#{@object.class.to_s.underscore}_resource".classify
+      @klass_name   = options.fetch('class_name', resource_name)
+    end
+
+    def to_hash
+      resource_klass = Resources::Discovery.resource_for_name(@object, resource_class: @klass_name)
+      resource       = resource_klass.new(@object, include: @includes)
+      serialized     = { 'data' => resource.to_hash }
+      relationships  = resource.relationships
+      included_data  = assemble_included_data(relationships)
+
+      if included_data.present?
+        included_data.uniq! do |inc_data|
+          inc_data['id'] + inc_data['type']
+        end
+        serialized['included'] = included_data
+      end
+
+      serialized['meta'] = @meta if @meta.present?
+      serialized
+    end
+
+    def assemble_included_data(relationships)
+      relationships.flat_map do |relationship|
+        next if relationship.resources.blank?
+        relationship.resources.map(&:to_hash)
+      end.compact
+    end
+  end
+
+  class CollectionSerializer
+    def initialize(objects, options = {})
+      @meta     = options.fetch('meta', Hash.new).stringify_keys
+      @objects  = objects
+      @includes = options.fetch('include', [])
+      @klass_name   = options.fetch('class_name', nil)
+    end
+
+    def to_hash
+      serialized = {}
+      included_data = []
+
+      data_array = @objects.map do |object|
+        resource_name = "#{object.class.to_s.underscore}_resource".classify
+        klass_name   = @klass_name || resource_name
+        resource_klass = Resources::Discovery.resource_for_name(object, resource_class: klass_name)
+        resource = resource_klass.new(object, include: @includes)
+        included_data += assemble_included_data(resource.relationships)
+        resource.to_hash
+      end
+
+      serialized['data'] = data_array
+
+      serialized['meta'] = @meta if @meta
+
+      if included_data.present?
+        included_data.uniq! do |inc_data|
+          inc_data['id'] + inc_data['type']
+        end
+        serialized['included'] = included_data
+      end
+
+      serialized
+    end
+
+    def assemble_included_data(relationships)
+      relationships.flat_map do |relationship|
+        next if relationship.resources.blank?
+        relationship.resources.map(&:to_hash)
+      end.compact
+    end
+  end
+end
+

data/lib/json_api_ruby/version.rb

@@ -0,0 +1,3 @@
+module JsonApi
+  VERSION = '0.0.1.alpha'
+end

data/lib/json_api_ruby.rb

@@ -0,0 +1,8 @@
+module JsonApi
+end
+
+require_relative 'json_api_ruby/error_resource'
+require_relative 'json_api_ruby/serializer'
+require_relative 'json_api_ruby/resource'
+require_relative 'json_api_ruby/exceptions'
+require_relative 'json_api_ruby/configuration'