xing-backend 0.0.10

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 81e5fbc0eab9a8177181d26d407b447a7bde5e78
+  data.tar.gz: 5e55cf12697cab2d64f021c4e918643382867212
+SHA512:
+  metadata.gz: ae67633934b7e3b807aca8f178895a52d1751188b04c4cebfd051abf5076280eb9c9063ab612cc8c12137bf70c02ebb64bd4999339c1451d953f9a932c0a6316
+  data.tar.gz: 0ea48e465a1e35135b46c093161ddd836c8117b3568a2765cb223044f9a53a3dfb745d4d12306fc6b9a320c7c6c5ae4def2ca7d32d68b8c4bef478b03a5219a6

data/lib/deprecated_classes.rb

@@ -0,0 +1,28 @@
+require 'xing-backend'
+require 'active_support/deprecation'
+
+module Xing
+  DEPRECATED_CLASSES = {
+    :HypermediaJSONMapper      => Xing::Mappers::Base,
+    :BaseSerializer            => Xing::Serializers::Base,
+    :ResourcesSerializer       => Xing::Serializers::RootResources,
+    :JsonTreeLister            => Xing::Services::JsonTreeLister,
+    :ActiveModelErrorConverter => Xing::Services::ErrorConverter,
+    :RemoteSnapshotFetcher     => Xing::Services::SnapshotFetcher
+  }
+end
+
+#Xing::DEPRECATED_CLASSES.each do |old, new|
+
+  ## with great power comes great responsibility
+  #Object.const_set(old, ActiveSupport::Deprecation::DeprecatedConstantProxy.new(old, new))
+#end
+
+def Object.const_missing(name)
+  if (klass = ::Xing::DEPRECATED_CLASSES[name.to_sym])
+    warn "[DEPRECATION] #{name} is deprecated. Please use #{klass.to_s} instead."
+    klass
+  else
+    super
+  end
+end

data/lib/xing/controllers/base.rb

@@ -0,0 +1,40 @@
+require 'devise_token_auth'
+
+module Xing
+  module Controllers
+    class Base < ActionController::Base
+      include DeviseTokenAuth::Concerns::SetUserByToken
+
+      respond_to :json
+
+      protect_from_forgery
+      before_filter :check_format
+
+      def check_format
+        if request.subdomains.include? Xing.backend_subdomain
+          if request.headers["Accept"] =~ /json/
+            params[:format] = :json
+          else
+            render :nothing => true, :status => 406
+          end
+        end
+      end
+
+      def json_body
+        @json_body ||= request.body.read
+      end
+
+      def parse_json
+        @parsed_json ||= JSON.parse(json_body)
+      end
+
+      def failed_to_process(error_document)
+        render :status => 422, :json => error_document
+      end
+
+      def successful_create(new_resource_path)
+        render :status => 201, :json => {}, :location => new_resource_path
+      end
+    end
+  end
+end

data/lib/xing/controllers/root_resources_controller.rb

@@ -0,0 +1,12 @@
+require 'rails/rfc6570'
+
+module Xing
+  module Controllers
+    class RootResourcesController < ::Xing::Controllers::Base
+      def index
+        @resources = rfc6570_routes(ignore: %w(format), path_only: true)
+        render :json => Xing::Serializers::RootResources.new(@resources)
+      end
+    end
+  end
+end

data/lib/xing/engine.rb

@@ -0,0 +1,27 @@
+module Xing
+
+  class Engine < ::Rails::Engine
+    isolate_namespace Xing
+
+    config.autoload_paths += Dir[File.join(__FILE__, '../controllers/**/')]
+
+    config.generators do |g|
+      g.test_framework :rspec
+    end
+
+    # The ErrorConverter leverages (abuses?) the I18n mechanism to translate
+    # ActiveModel validation errors into Xing JSON resource errors.  Here we
+    # need to make sure the locales file for language 'json' is loaded for
+    # I18n.
+    initializer 'xing errors locales path' do
+      I18n.load_path += Dir[File.join(File.dirname(__FILE__), '..', 'config', 'locales', '*.{rb,yml}')]
+    end
+
+    # Set the backend subdomain if it hasn't been configured by the user.
+    initializer 'set subdomain' do
+      Xing.configure do |xng_config|
+        xng_config.backend_subdomain ||= 'api'
+      end
+    end
+  end
+end

data/lib/xing/mappers/base.rb

@@ -0,0 +1,135 @@
+# This code is only used in the context of Rails apps, and depends pretty
+# heavily on rails core extensions, so we are requiring them here.
+require 'active_support'
+require 'active_support/core_ext'
+
+module Xing
+  module Mappers
+    class Base
+      class MissingLinkException < Exception; end
+
+      # Subclasses must define:
+      #    aliases       -- for self.record
+      #    record_class  -- if the mapper maps to an AR object
+      #
+      # Subclasses should usually define:
+      #    assign_values  -- move values from JSON into the mapped AR record
+      #
+      # Subclasses may also want to define:
+      #    find_existing_record -- for locating the underlying AR record
+      #    build_new_record     -- for for instantiating a new underlying AR record
+      #    map_nested_models
+      #    build_errors         -- if simply copying AR errors is insufficient
+      #    save                 -- if they need to save more than 1 AR record
+
+      # When updating records, pass the locator (e.g. DB id, url_slug, or other
+      # unique resource extracted from the resource path) as the second argument.
+      def initialize(json, locator = nil)
+        @source_json = json
+        if @source_json.is_a? String
+          @source_hash = JSON.parse(json).with_indifferent_access
+        else
+          @source_hash = @source_json
+        end
+        @locator = locator
+      end
+      attr_accessor :locator, :error_data
+      attr_writer :record
+
+      def router
+        Rails.application.routes
+      end
+
+      def normalize_path(path)
+        path = "/#{path}"
+        path.squeeze!('/')
+        path.sub!(%r{/+\Z}, '')
+        path.gsub!(/(%[a-f0-9]{2})/) { $1.upcase }
+        path = '/' if path == ''
+        path
+      end
+
+      # This helper is used to deconstruct a URL for the purpose of extracting
+      # components.  For example, menu_item_mapper uses it to extract the url_slug
+      # component of a page route. We are here abusing recognize_path, which isn't
+      # supposed to be used outside of tests (see
+      # https://github.com/rails/rails/issues/2656), but we don't know what the
+      # alternative is.
+      def route_to(path)
+        path = "http://#{BACKEND_SUBDOMAIN}.example.com#{normalize_path(path)}";
+        router.recognize_path(path)
+      end
+
+      # Default save - subclasses might override
+      def save
+        perform_mapping
+        unless self.errors[:data].present?
+          self.record.save
+        end
+      end
+
+      # Default for finding an existing record - override this *or* define
+      # #record_class (e.g. `return Page`
+      def find_existing_record
+        @record = record_class.find(@locator)
+      end
+
+      # Default for building a new record - override this *or* define #record_class
+      # (e.g. `return Page`
+      def build_new_record
+        @record = record_class.new
+      end
+
+      def perform_mapping
+        data = unwrap_data(@source_hash)
+        self.error_data = Hash.new { |hash, key| hash[key] = {} }
+
+        assign_values(data)
+        map_nested_models
+        build_errors
+      end
+
+      def unwrap_data(hash)
+        hash['data'].with_indifferent_access
+      end
+
+      def wrap_data(hash)
+        {
+          data: hash
+        }
+      end
+
+      def record
+        @record ||= if !locator.nil?
+                      find_existing_record
+                    else
+                      build_new_record
+                    end
+      end
+
+      def assign_values(data_hash)
+        # Override in subclasses to assign needed values here
+        record  # force loading or creation of the underlying DB record
+        update_record
+      end
+
+      # Do nothing if there are no nested models
+      # Override this method in subclass if necessary
+      def map_nested_models
+      end
+
+      def build_errors
+        self.add_ar_arrors(self.record)
+      end
+
+      def errors
+        wrap_data(error_data)
+      end
+
+      def add_ar_arrors(object)
+        object_errors = ActiveModelErrorConverter.new(object).convert
+        error_data.deep_merge!(object_errors)
+      end
+    end
+  end
+end

data/lib/xing/mappers.rb

@@ -0,0 +1,6 @@
+module Xing
+  module Mappers
+  end
+end
+
+require 'xing/mappers/base'

data/lib/xing/serializers/base.rb

@@ -0,0 +1,50 @@
+require 'rails'
+require 'active_model_serializers'
+
+module Xing
+  module Serializers
+
+    # The base class for all Xing serializers that produce
+    # Xing Hypermedia JSON resources.  In general, subclasses
+    # of Xing::Serializers::Base should:
+    #
+    #   * Define a links method that returns a hash of hypermedia links to
+    #     related resources
+    #
+    #   * Specify the attributes (via the ActiveModel::Serializers 'attributes'
+    #     class method) that will be copied into the data: block
+    #     of the generated resource.
+    #
+    #   * Define methods for any attributes that do not exist as plain attributes
+    #     in the ActiveModel being serialized.  Note that this may (and often will) include
+    #     calling other serializers on related resources or other data, in order to
+    #     generate embedded resources.
+    #
+    # Xing serializers descend from ActiveModel::Serializer and are typically
+    # instantiated with an instance of an ActiveModel model in the usual way.
+    #
+    class Base < ActiveModel::Serializer
+
+      def routes
+        Rails.application.routes.url_helpers
+      end
+
+      def root
+        false
+      end
+
+      def as_json_with_wrap(options={})
+        {
+          :links => links,
+          :data => as_json_without_wrap
+        }
+      end
+
+      def links
+        {}
+      end
+
+      alias_method_chain :as_json, :wrap
+    end
+  end
+end

data/lib/xing/serializers/root_resources.rb

@@ -0,0 +1,9 @@
+module Xing
+  module Serializers
+    class RootResources < Base
+      def links
+        object
+      end
+    end
+  end
+end

data/lib/xing/serializers.rb

@@ -0,0 +1,7 @@
+module Xing
+  module Serializers
+  end
+end
+
+require 'xing/serializers/base'
+require 'xing/serializers/root_resources'

data/lib/xing/services/error_converter.rb

@@ -0,0 +1,47 @@
+module Xing
+  module Services
+    class ErrorConverter
+
+
+      def initialize(am_object)
+        @am_object = am_object
+      end
+      attr_reader :am_object
+
+      # This is a terrible hack to preserve the semantic meaning of
+      # different error types -- neccesary because ActiveModel::Errors
+      # frustratingly translates semantic error messages through i18n
+      # as soon as it gets them
+      def json_errors
+        @json_errors ||= begin
+                           old_locale = I18n.locale
+                           I18n.locale = "json"
+                           am_object.valid?
+                           error_hash = am_object.errors.to_hash.deep_dup
+                           I18n.locale = old_locale
+                           error_hash
+                         end
+      end
+
+      def regular_errors
+        @regular_errors ||= begin
+                              am_object.valid?
+                              am_object.errors.to_hash.deep_dup
+                            end
+      end
+
+      def convert
+        final_errors = {}
+        json_errors.each_key do |key|
+          final_errors[key] = {
+            :type => json_errors[key][0],
+            :message => regular_errors[key][0]
+          }
+        end
+        final_errors
+      end
+
+
+    end
+  end
+end

data/lib/xing/services/json_tree_lister.rb

@@ -0,0 +1,56 @@
+require 'active_model_serializers'
+require 'active_support/core_ext'
+
+module Xing
+  module Services
+    class JsonTreeLister
+
+      class TreeNode
+        include ActiveModel::SerializerSupport
+
+        def initialize(node, children)
+          @node = node
+          @children = children
+        end
+
+        attr_reader :node, :children
+      end
+
+      def initialize(nodes, node_serializer)
+        @nodes = nodes
+        @node_serializer = node_serializer
+        @stack = [[]]
+        @path = []
+      end
+
+      def render_node(node, children)
+        @node_serializer.new(TreeNode.new(node, children)).as_json
+      end
+
+      def pop_level
+        children = @stack.pop
+        @stack.last << render_node(@path.pop, children)
+      end
+
+      def render
+        (@nodes + [nil]).each_cons(2) do |this, after|
+          until @path.empty? or @path.last.is_ancestor_of?(this)
+            pop_level
+          end
+          if after.nil? or !this.is_ancestor_of?(after)
+            @stack.last << render_node(this, [])
+          else
+            @path << this
+            @stack << []
+          end
+        end
+        until @path.empty?
+          pop_level
+        end
+        return @stack.last.first
+      end
+
+
+    end
+  end
+end

data/lib/xing/services/snapshot_fetcher.rb

@@ -0,0 +1,33 @@
+require 'typhoeus'
+require 'addressable/uri'
+require 'xing/services/snapshot_writer'
+require 'sidekiq/worker'
+
+module Xing::Services
+  class SnapshotFetcher
+    include Sidekiq::Worker
+    include SnapshotWriter
+
+    def perform(url, path)
+      admin_server = Rails.application.secrets.snapshot_server['url']
+      user_password = "#{Rails.application.secrets.snapshot_server['user']}:#{Rails.application.secrets.snapshot_server['password']}"
+      snapshot_url = Addressable::URI.join(url,path).to_s
+      request = Typhoeus::Request.new(admin_server, userpwd: user_password, params: { url: snapshot_url })
+
+      hydra = Typhoeus::Hydra.new
+      hydra.queue(request)
+      hydra.run
+
+      response = request.response
+
+      if response.success?
+        html = response.body
+        write(path, html)
+      else
+        logger.warn response.status_message
+        logger.warn response.body
+        raise "Query to #{admin_server} for #{path} failed!"
+      end
+    end
+  end
+end

data/lib/xing/services/snapshot_writer.rb

@@ -0,0 +1,19 @@
+module Xing::Services
+  module SnapshotWriter
+    def write(path, html)
+      if Rails.env.test?
+        snapshot_file = "#{ Rails.root }/spec/fixtures/sitemap_scratch/#{path.present? ? path : 'index'}.html"
+      else
+        snapshot_file = "#{ Rails.root }/public/frontend_snapshots/#{path.present? ? path : 'index'}.html"
+      end
+      dirname = File.dirname(snapshot_file)
+      unless File.directory?(dirname)
+        FileUtils.mkdir_p(dirname)
+      end
+
+      File.open(snapshot_file, "w+:ASCII-8BIT:UTF-8") do |f|
+        f.write(html)
+      end
+    end
+  end
+end

data/lib/xing/services.rb

@@ -0,0 +1,9 @@
+module Xing
+  module Services
+  end
+end
+
+require 'xing/services/json_tree_lister'
+require 'xing/services/error_converter'
+require 'xing/services/snapshot_fetcher'
+require 'xing/services/snapshot_writer'

data/lib/xing-backend.rb

@@ -0,0 +1,34 @@
+require 'rails'
+require 'xing_backend_token_auth'
+require 'rails/rfc6570'
+require 'sidekiq'
+
+module Xing
+  mattr_accessor :backend_subdomain
+
+  # Configure xing via pattern similar to Rails:
+  #
+  # Xing.configure do |config|
+  #   config.setting =  'value'
+  # end
+  #
+  # Supported settings right now are:
+  #   * backend_subdomain (default: 'api')
+  def self.configure(&block)
+    yield self
+  end
+
+  module Controllers
+    autoload :Base,                    'xing/controllers/base'
+
+    # NOTE: The rails router expects the the controller to have "Controller" as
+    # the suffix of the name, or it complains.
+    autoload :RootResourcesController, 'xing/controllers/root_resources_controller'
+  end
+end
+
+require 'xing/mappers'
+require 'xing/engine'
+require 'xing/serializers'
+require 'xing/services'
+require 'deprecated_classes'

data/spec/deprecated_classes/active_model_error_converter_spec.rb

@@ -0,0 +1,11 @@
+require 'deprecated_classes'
+
+describe ActiveModelErrorConverter, :type => :deprecation do
+  let :resource do
+    double('resource')
+  end
+
+  it "should be the correct class" do
+    expect(ActiveModelErrorConverter.new(resource)).to be_a(Xing::Services::ErrorConverter)
+  end
+end

data/spec/deprecated_classes/base_serializer_spec.rb

@@ -0,0 +1,11 @@
+require 'deprecated_classes'
+
+describe BaseSerializer, :type => :deprecation do
+  let :resource do
+    double('resource')
+  end
+
+  it "should be the correct class" do
+    expect(BaseSerializer.new(resource)).to be_a(Xing::Serializers::Base)
+  end
+end

data/spec/deprecated_classes/hypermedia_json_mapper_spec.rb

@@ -0,0 +1,11 @@
+require 'deprecated_classes'
+
+describe HypermediaJSONMapper, :type => :deprecation do
+  let :json do
+    double('json')
+  end
+
+  it "should be the correct class" do
+    expect(HypermediaJSONMapper.new(json)).to be_a(Xing::Mappers::Base)
+  end
+end

data/spec/deprecated_classes/json_tree_lister_spec.rb

@@ -0,0 +1,14 @@
+require 'deprecated_classes'
+
+describe JsonTreeLister, :type => :deprecation do
+  let :models do
+    double('models')
+  end
+  let :serializer do
+    double('serializer')
+  end
+
+  it "should be the correct class" do
+    expect(JsonTreeLister.new(models, serializer)).to be_a(Xing::Services::JsonTreeLister)
+  end
+end

data/spec/deprecated_classes/remote_snapshot_fetcher_spec.rb

@@ -0,0 +1,8 @@
+
+require 'deprecated_classes'
+
+describe RemoteSnapshotFetcher do
+  it "should be the correct class" do
+    expect(RemoteSnapshotFetcher.new()).to be_a(Xing::Services::SnapshotFetcher)
+  end
+end

data/spec/deprecated_classes/resources_serializer_spec.rb

@@ -0,0 +1,12 @@
+
+require 'deprecated_classes'
+
+describe ResourcesSerializer do
+  let :resource do
+    double('hash_of_links')
+  end
+
+  it "should be the correct class" do
+    expect(ResourcesSerializer.new(resource)).to be_a(Xing::Serializers::RootResources)
+  end
+end

data/spec/xing/controllers/base_spec.rb

@@ -0,0 +1,7 @@
+require 'xing-backend'
+
+describe Xing::Controllers::Base, :type => :controller do
+  it "should exist" do
+    expect(Xing::Controllers::Base).not_to be_nil
+  end
+end

data/spec/xing/controllers/root_resources_controller_spec.rb

@@ -0,0 +1,8 @@
+require 'xing-backend'
+
+describe Xing::Controllers::RootResourcesController, :type => :controller do
+  it "should exist" do
+    expect(Xing::Controllers::RootResourcesController).not_to be_nil
+  end
+
+end