yaks-html 0.6.0.alpha → 0.6.0.alpha.1

data/yaks/lib/yaks/default_policy.rb

@@ -1,100 +0,0 @@
-module Yaks
-  class DefaultPolicy
-    include Util
-
-    # Default policy options.
-    DEFAULTS = {
-      rel_template: "rel:{rel}",
-      namespace: Kernel
-    }
-
-    # @!attribute [r]
-    #   @return [Hash]
-    attr_reader :options
-
-    # @param options [Hash] options
-    def initialize(options = {})
-      @options = DEFAULTS.merge(options)
-    end
-
-    # @param model [Object]
-    # @return [Class] A mapper, typically a subclass of Yaks::Mapper
-    #
-    # @raise [NameError] only occurs when the model is anything but a collection.
-    def derive_mapper_from_object(model)
-      if model.respond_to? :to_ary
-        if m = model.first
-          name = m.class.name.split('::').last + 'CollectionMapper'
-          begin
-            return @options[:namespace].const_get(name)
-          rescue NameError
-          end
-        end
-        begin
-          return @options[:namespace].const_get(:CollectionMapper)
-        rescue NameError
-        end
-        CollectionMapper
-      else
-        name = model.class.name.split('::').last
-        @options[:namespace].const_get(name + 'Mapper')
-      end
-    end
-
-    # Derive the a mapper type name
-    #
-    # This returns the 'system name' for a mapper,
-    # e.g. ShowEventMapper => show_event.
-    #
-    # @param [Class]  mapper_class
-    #
-    # @return [String]
-    def derive_type_from_mapper_class(mapper_class)
-      underscore(mapper_class.name.split('::').last.sub(/Mapper$/, ''))
-    end
-
-    # Derive the mapper type name from a collection
-    #
-    # This inspects the first element of the collection, so it
-    # requires a non-empty collection. Will return nil if the
-    # collection is empty.
-    #
-    # @param [#first] collection
-    #
-    # @return [String|nil]
-    #
-    # @raise [NameError]
-    def derive_type_from_collection(collection)
-      if collection.any?
-        derive_type_from_mapper_class(
-          derive_mapper_from_object(collection.first)
-        )
-      end
-    end
-
-    def derive_mapper_from_association(association)
-      @options[:namespace].const_get("#{camelize(association.singular_name)}Mapper")
-    end
-
-    # @param association [Yaks::Mapper::Association]
-    # @return [String]
-    def derive_rel_from_association(association)
-      expand_rel( association.name )
-    end
-
-    # @param relname [String]
-    # @return [String]
-    def expand_rel(relname)
-      URITemplate.new(@options[:rel_template]).expand(rel: relname)
-    end
-
-    # @param format_class [Class]
-    # @return [#call] format_class
-    def serializer_for_format(format_class)
-      {
-        json: JSON.method(:pretty_generate),
-        html: :to_html.to_proc
-      }.fetch(format_class.serializer)
-    end
-  end
-end

data/yaks/lib/yaks/format.rb

@@ -1,87 +0,0 @@
-module Yaks
-  class Format
-    extend Forwardable
-    include Util
-    include FP::Callable
-
-    # @!attribute [r] options
-    #   @return [Hash]
-    attr_reader :options
-
-    def_delegators :resource, :links, :attributes, :subresources
-
-    protected :links, :attributes, :subresources, :options
-
-    # @param [Hash] options
-    # @return [Hash]
-    def initialize(options = {})
-      @options = options
-    end
-
-    # @param [Yaks::Resource] resource
-    # @return [Hash]
-    def call(resource)
-      serialize_resource(resource)
-    end
-    alias serialize call
-
-    class << self
-      attr_reader :format_name, :serializer, :mime_type
-
-      def all
-        @formats ||= []
-      end
-
-      # @param [Constant] klass
-      # @param [Symbol] format_name
-      # @param [String] mime_type
-      # @return [Array]
-      def register(format_name, serializer, mime_type)
-        @format_name = format_name
-        @serializer = serializer
-        @mime_type = mime_type
-
-        Format.all << self
-      end
-
-      # @param [Symbol] format_name
-      # @return [Constant]
-      # @raise [KeyError]
-      def by_name(format_name)
-        find(:format_name, format_name)
-      end
-
-      # @param [Symbol] mime_type
-      # @return [Constant]
-      # @raise [KeyError]
-      def by_mime_type(mime_type)
-        find(:mime_type, mime_type)
-      end
-
-      def by_accept_header(accept_header)
-        mime_type = Rack::Accept::Charset.new(accept_header).best_of(mime_types.values)
-        if mime_type
-          by_mime_type(mime_type)
-        else
-          yield if block_given?
-        end
-      end
-
-      def mime_types
-        Format.all.each_with_object({}) do
-          |format, memo| memo[format.format_name] = format.mime_type
-        end
-      end
-
-      def names
-        mime_types.keys
-      end
-
-      private
-
-      def find(key, cond)
-        Format.all.detect {|format| format.send(key) == cond }
-      end
-    end
-  end
-end

data/yaks/lib/yaks/format/collection_json.rb

@@ -1,42 +0,0 @@
-module Yaks
-  class Format
-    class CollectionJson < self
-      register :collection_json, :json, 'application/vnd.collection+json'
-
-      include FP
-
-      # @param [Yaks::Resource] resource
-      # @return [Hash]
-      def serialize_resource(resource)
-        result = {
-          version: "1.0",
-          items: serialize_items(resource)
-        }
-        result[:href] = resource.self_link.uri if resource.self_link
-        {collection: result}
-      end
-
-      # @param [Yaks::Resource] resource
-      # @return [Array]
-      def serialize_items(resource)
-        resource.map do |item|
-          attrs = item.attributes.map do |name, value|
-            {
-              name: name,
-              value: value
-            }
-          end
-          result = { data: attrs }
-          result[:href] = item.self_link.uri if item.self_link
-          item.links.each do |link|
-            next if link.rel.equal? :self
-            result[:links] = [] unless result.key?(:links)
-            result[:links] << {rel: link.rel, href: link.uri}
-            result[:links].last[:name] = link.title if link.title
-          end
-          result
-        end
-      end
-    end
-  end
-end

data/yaks/lib/yaks/format/hal.rb

@@ -1,82 +0,0 @@
-# -*- coding: utf-8 -*-
-
-module Yaks
-  class Format
-    # Hypertext Application Language (http://stateless.co/hal_specification.html)
-    #
-    # A lightweight JSON Hypermedia message format.
-    #
-    # Options: +:plural_links+ In HAL, a single rel can correspond to
-    # a single link, or to a list of links. Which rels are singular
-    # and which are plural is application-dependant. Yaks assumes all
-    # links are singular. If your resource might contain multiple
-    # links for the same rel, then configure that rel to be plural. In
-    # that case it will always be rendered as a collection, even when
-    # the resource only contains a single link.
-    #
-    # @example
-    #
-    #   yaks = Yaks.new do
-    #     format_options :hal, {plural_links: [:related_content]}
-    #   end
-    #
-    class Hal < self
-      register :hal, :json, 'application/hal+json'
-
-      protected
-
-      # @param [Yaks::Resource] resource
-      # @return [Hash]
-      def serialize_resource(resource)
-        # The HAL spec doesn't say explicitly how to deal missing values,
-        # looking at client behavior (Hyperagent) it seems safer to return an empty
-        # resource.
-        #
-        result = resource.attributes
-        result = result.merge(:_links => serialize_links(resource.links)) unless resource.links.empty?
-        result = result.merge(:_embedded => serialize_embedded(resource.subresources)) unless resource.subresources.empty?
-        result
-      end
-
-      # @param [Array] links
-      # @return [Hash]
-      def serialize_links(links)
-        links.reduce({}, &method(:serialize_link))
-      end
-
-      # @param [Hash] memo
-      # @param [Yaks::Resource::Link]
-      # @return [Hash]
-      def serialize_link(memo, link)
-        hal_link = {href: link.uri}
-        hal_link.merge!(link.options)
-
-        memo[link.rel] = if singular?(link.rel)
-                           hal_link
-                         else
-                           (memo[link.rel] || []) + [hal_link]
-                         end
-        memo
-      end
-
-      # @param [String] rel
-      # @return [Boolean]
-      def singular?(rel)
-        !options.fetch(:plural_links) { [] }.include?(rel)
-      end
-
-      # @param [Array] subresources
-      # @return [Hash]
-      def serialize_embedded(subresources)
-        subresources.each_with_object({}) do |(rel, resources), memo|
-          memo[rel] = if resources.collection?
-                        resources.map( &method(:serialize_resource) )
-                      else
-                        serialize_resource(resources) unless resources.null_resource?
-                      end
-        end
-      end
-
-    end
-  end
-end

data/yaks/lib/yaks/format/json_api.rb

@@ -1,86 +0,0 @@
-# -*- coding: utf-8 -*-
-
-module Yaks
-  class Format
-    class JsonAPI < self
-      register :json_api, :json, 'application/vnd.api+json'
-
-      include FP
-
-      # @param [Yaks::Resource] resource
-      # @return [Hash]
-      def call(resource)
-        main_collection = resource.map(&method(:serialize_resource))
-
-        { pluralize(resource.type) => main_collection }.tap do |serialized|
-          linked = resource.each_with_object({}) do |res, hsh|
-            serialize_linked_subresources(res.subresources, hsh)
-          end
-          serialized.merge!(linked: linked) unless linked.empty?
-        end
-      end
-
-      # @param [Yaks::Resource] resource
-      # @return [Hash]
-      def serialize_resource(resource)
-        result = resource.attributes
-
-        unless resource.subresources.empty?
-          result[:links] = serialize_links(resource.subresources)
-        end
-
-        if resource.self_link && !result.key?(:href)
-          result[:href]  = resource.self_link.uri
-        end
-
-        result
-      end
-
-      # @param [Yaks::Resource] subresource
-      # @return [Hash]
-      def serialize_links(subresources)
-        subresources.each_with_object({}) do |(_name, resource), hsh|
-          next if resource.instance_of? NullResource
-          key = resource.collection? ? pluralize(resource.type) : resource.type
-          hsh[key] = serialize_link(resource)
-        end
-      end
-
-      # @param [Yaks::Resource] resource
-      # @return [Array, String]
-      def serialize_link(resource)
-        resource.collection? ? resource.map(&send_with_args(:[], :id)) : resource[:id]
-      end
-
-      # @param [Hash] subresources
-      # @param [Hash] hsh
-      # @return [Hash]
-      def serialize_linked_subresources(subresources, hsh)
-        subresources.values.each do |resources|
-          serialize_linked_resources(resources, hsh)
-        end
-      end
-
-      # @param [Array] resources
-      # @param [Hash] linked
-      # @return [Hash]
-      def serialize_linked_resources(resources, linked)
-        resources.each_with_object(linked) do |resource, memo|
-          serialize_subresource(resource, memo)
-        end
-      end
-
-      # {shows => [{id: 3, name: 'foo'}]}
-      #
-      # @param [Yaks::Resource] resource
-      # @param [Hash] linked
-      # @return [Hash]
-      def serialize_subresource(resource, linked)
-        key = pluralize(resource.type)
-        set = linked.fetch(key) { Set.new }
-        linked[key] = (set << serialize_resource(resource))
-        serialize_linked_subresources(resource.subresources, linked)
-      end
-    end
-  end
-end

data/yaks/lib/yaks/fp.rb

@@ -1,26 +0,0 @@
-module Yaks
-  module FP
-    extend self
-
-    # @param [Symbol, String] name
-    # @return [Proc]
-    def curry_method(name)
-      method(name).to_proc.curry
-    end
-
-
-    # @return [Proc]
-    def identity_function
-      ->(x) {x}
-    end
-    I = identity_function
-
-    # @param [Symbol] symbol
-    # @param [Array] args
-    # @param [Proc] blk
-    # @return [Proc]
-    def send_with_args(symbol, *args, &blk)
-      ->(obj) { obj.method(symbol).(*args, &blk) }
-    end
-  end
-end

data/yaks/lib/yaks/fp/callable.rb

@@ -1,9 +0,0 @@
-module Yaks
-  module FP
-    module Callable
-      def to_proc
-        method(:call).to_proc
-      end
-    end
-  end
-end

data/yaks/lib/yaks/fp/hash_updatable.rb

@@ -1,19 +0,0 @@
-module Yaks
-  module FP
-
-    class HashUpdatable < Module
-      # @param [Array] attributes
-      # @return [Symbol]
-      def initialize(*attributes)
-        define_method :update do |updates|
-          self.class.new(
-            attributes.each_with_object({}) {|attr, hsh|
-              hsh[attr] = updates.fetch(attr) { send(attr) }
-            }
-          )
-        end
-      end
-    end
-
-  end
-end