mno-enterprise-core 2.0.0

data/lib/her_extension/model/associations/has_many_association.rb

@@ -0,0 +1,115 @@
+# PR:
+# fixed options loading in dynamically defined method
+# changed build to not add the parent key automatically
+# changed create to send raw parameters instead of doing smart stuff
+module Her
+  module Model
+    module Associations
+      class HasManyAssociation < Association
+
+        # @private
+        def self.attach(klass, name, opts)
+          opts = {
+            :class_name     => name.to_s.classify,
+            :name           => name,
+            :data_key       => name,
+            :default        => Her::Collection.new,
+            :path           => "/#{name}",
+            :inverse_of => nil
+          }.merge(opts)
+          klass.associations[:has_many] << opts
+
+          klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{name}
+              cached_name = :"@_her_association_#{name}"
+              cached_data = (instance_variable_defined?(cached_name) && instance_variable_get(cached_name))
+              opts = Marshal.load(#{Marshal.dump(opts).inspect})
+              cached_data || instance_variable_set(cached_name, Her::Model::Associations::HasManyAssociation.proxy(self, opts))
+            end
+          RUBY
+        end
+
+        # Initialize a new object with a foreign key to the parent
+        #
+        # @example
+        #   class User
+        #     include Her::Model
+        #     has_many :comments
+        #   end
+        #
+        #   class Comment
+        #     include Her::Model
+        #   end
+        #
+        #   user = User.find(1)
+        #   new_comment = user.comments.build(:body => "Hello!")
+        #   new_comment # => #<Comment body="Hello!">
+        #
+        def build(attributes = {})
+          @klass.build(attributes)
+        end
+
+        # Post an object to the nested resource collection endpoint then
+        # refetch the nested collection
+        #
+        # @example
+        #   class User
+        #     include Her::Model
+        #     has_many :comments
+        #   end
+        #
+        #   class Comment
+        #     include Her::Model
+        #   end
+        #
+        #   user = User.find(1)
+        #   user.comments.create(:body => "Hello!")
+        #   user.comments # => [#<Comment id=2 user_id=1 body="Hello!">]
+        def create(attributes = {})
+          resp = self.execute_request(:create,attributes)
+          @klass.build(resp)
+        end
+
+        # Consider removing - not sure this method on a has_many collection has any meaning
+        def update(attributes = {})
+          self.execute_request(:update,attributes)
+        end
+
+        # Consider removing - not sure this method on a has_many collection has any meaning
+        def destroy(attributes = {})
+          self.execute_request(:destroy,attributes)
+        end
+
+        def execute_request(action, attrs)
+          attributes = HashWithIndifferentAccess.new(attrs)
+
+          # Post data to the collection endpoint
+          resource = nil
+          path = self.build_request_path
+          method = self.method_for(action.to_sym)
+
+          # Add ID to path if resource method
+          if [:put, :patch, :delete].include?(method.to_sym)
+            path += "/#{attributes[@klass.primary_key]}"
+          end
+
+          params = self.to_params(attributes).merge(:_method => method, :_path => path)
+          self.request(params) do |parsed_data, response|
+            resource = parsed_data if response.success?
+          end
+
+          # Reload nested collection
+          self.reload if resource
+
+          resource
+        end
+
+        # Override fetch to not do any smart stuff...
+        def fetch
+          super
+        end
+
+      end
+    end
+  end
+end

data/lib/her_extension/model/attributes.rb

@@ -0,0 +1,43 @@
+module Her
+  module Model
+    # TODO: make PR to Her project
+    # This patch fixes the detection of changed attributes
+    module Attributes
+      extend ActiveSupport::Concern
+
+
+      module ClassMethods
+        # Define the attributes that will be used to track dirty attributes and validations
+        #
+        # @param [Array] attributes
+        # @example
+        #   class User
+        #     include Her::Model
+        #     attributes :name, :email
+        #   end
+        def attributes(*attributes)
+          define_attribute_methods attributes
+
+          attributes.each do |attribute|
+            attribute = attribute.to_sym
+
+            unless instance_methods.include?(:"#{attribute}=")
+              define_method("#{attribute}=") do |value|
+                @attributes[:"#{attribute}"] = nil unless @attributes.include?(:"#{attribute}")
+                self.send(:"#{attribute}_will_change!") if @attributes[:"#{attribute}"] != value
+                @attributes[:"#{attribute}"] = value
+              end
+            end
+
+            unless instance_methods.include?(:"#{attribute}?")
+              define_method("#{attribute}?") do
+                @attributes.include?(:"#{attribute}") && @attributes[:"#{attribute}"].present?
+              end
+            end
+          end
+        end
+        
+      end
+    end
+  end
+end

data/lib/her_extension/model/orm.rb

@@ -0,0 +1,59 @@
+# FIX: Reset params when blank_relation is called so that query statement (like where)
+# automatically start fresh
+# 
+# FIX: scope to create real isolated scopes for each Her::Model
+#
+# FIX: add put method on model
+module Her
+  module Model
+    module ORM
+      
+      # Send raw PUT request to model - no data encapsulation performed
+      def put(attrs)
+        method = :put
+        self.class.request(attrs.merge(:_method => method, :_path => request_path)) do |parsed_data, response|
+          return parsed_data
+        end
+      end
+      
+      module ClassMethods
+        # Create a new chainable scope
+        #
+        # @example
+        #   class User
+        #     include Her::Model
+        #
+        #     scope :admins, lambda { where(:admin => 1) }
+        #     scope :page, lambda { |page| where(:page => page) }
+        #   enc
+        #
+        #   User.admins # Called via GET "/users?admin=1"
+        #   User.page(2).all # Called via GET "/users?page=2"
+        def scope(name, code)
+          
+          # Add the scope method to the class
+          metaclass = (class << self; self end)
+          metaclass.send(:define_method, name) do |*args|
+            instance_exec(*args, &code)
+          end
+          Relation.scopes["#{self.to_s}.#{name}"] = code
+          
+          # Add the scope method to the Relation class
+          Relation.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{name}(*args)
+              parent_klass = @parent.instance_variable_get("@klass") || @parent.to_s
+              instance_exec(*args,&self.class.scopes["\#{parent_klass}.#{name}"])
+            end
+          RUBY
+        end
+        
+        private
+          def blank_relation
+            @blank_relation ||= Relation.new(self)
+            @blank_relation.params = {}
+            @blank_relation
+          end
+      end
+    end
+  end
+end

data/lib/her_extension/model/parse.rb

@@ -0,0 +1,40 @@
+# TODO: PR to HER
+# Fix to_params when embeded_params is nil
+# Fix to_params when changes is nil 
+# --> allow all params - this is required to be able to make class level 
+#     requests like MyModel.post(path,{some: 'data'})
+#
+module Her
+  module Model
+    # This module handles resource data parsing at the model level (after the parsing middleware)
+    module Parse
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        # @private
+        def to_params(attributes, changes = nil)
+          filtered_attributes = attributes.dup.symbolize_keys
+          filtered_attributes.merge!(embeded_params(attributes) || {})
+          if her_api && her_api.options[:send_only_modified_attributes] && !changes.nil?
+            filtered_attributes = changes.symbolize_keys.keys.inject({}) do |hash, attribute|
+              hash[attribute] = filtered_attributes[attribute]
+              hash
+            end
+          end
+
+          if include_root_in_json?
+            if json_api_format?
+              { included_root_element => [filtered_attributes] }
+            else
+              { included_root_element => filtered_attributes }
+            end
+          else
+            filtered_attributes
+          end
+        end
+        
+      end
+    end
+  end
+end

data/lib/her_extension/model/relation.rb

@@ -0,0 +1,92 @@
+require 'digest/md5'
+
+# TODO: we should do a PR to the HER project which includes
+# smarter filtering and more reliable caching
+# Before doing so, we make the filtering behavior customizable
+# (E.g.: configure name of filter/sort/limit keys)
+module Her
+  module Model
+    class Relation
+      def initialize(parent)
+        @parent = parent
+        @params = {}
+      end
+
+      # Fetch a collection of resources
+      def fetch
+        path = @parent.build_request_path(@params)
+        method = @parent.method_for(:find)
+        @parent.request(@params.merge(:_method => method, :_path => path)) do |parsed_data, response|
+          @parent.new_collection(parsed_data)
+        end
+      end
+
+      # Override Her::Model::Relation#where
+      # to follow jsonapi.org standards
+      # Use filter instead of raw parameters
+      def where(params = {})
+        return self if !params || params.empty?
+        self.params[:filter] ||= {}
+        self.params[:filter].merge!(params)
+        self
+      end
+      alias all where
+
+      # E.g:
+      # Product.order_by('created_at.desc','name.asc')
+      def order_by(*args)
+        return self if args.empty?
+        self.params[:sort] = [self.params[:sort],args].flatten.compact.uniq
+        self
+      end
+      alias sort_by order_by
+
+      # ActiveRecord-like order
+      # Product.order("created_at DESC, name ASC")
+      def order(string_query)
+        return self if !string_query || string_query.empty?
+        args = string_query.split(',').map do |q|
+          field, direction = q.strip.split(/\s+/).compact
+          [field, direction ? direction.downcase : nil].join('.')
+        end
+        self.order_by(*args)
+      end
+      alias sort order
+
+      # Limit the number of results returned
+      def limit(max = nil)
+        return self if !max
+        self.params[:limit] = max
+        self
+      end
+
+      # Skip result rows
+      def skip(nrows = nil)
+        return self if !nrows
+        self.params[:skip] = nrows
+        self
+      end
+
+      # Reset the query parameters
+      def reset_params
+        @params.clear
+      end
+
+      # Refetch the relation
+      def reload
+        fetch
+      end
+
+      # Hold the scopes defined on Her::Model classes
+      # E.g.: scope :admin, -> { where(admin: 1) }
+      def self.scopes
+        @scopes ||= {}
+      end
+
+      private
+        def query_checkum
+          Digest::MD5.hexdigest(Marshal.dump(@params))
+        end
+    end
+  end
+end

data/lib/her_extension/validations/remote_uniqueness_validation.rb

@@ -0,0 +1,33 @@
+# TODO:
+# - spec module
+# - spec that validator ignores records with the same id
+module HerExtension
+  module Validations
+    
+    # Validate the uniqueness of a field by performing a remote API call
+    class RemoteUniquenessValidator < ::ActiveModel::EachValidator
+      def validate_each(record,attribute,value)
+        list = record.class.where({ attribute => value }).limit(1)
+        
+        if list.reject { |e| e.id == record.id }.any?
+          error_options = options.except(:case_sensitive, :scope, :conditions)
+          error_options[:value] = value
+          record.errors.add(attribute, :taken, error_options)
+        end
+      end
+    end
+    
+    # This module overrides validates_uniqueness_of
+    module RemoteUniquenessValidation
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      module ClassMethods
+        def validates_uniqueness_of(*attr_names)
+          validates_with RemoteUniquenessValidator, _merge_attributes(attr_names)
+        end
+      end
+    end
+  end
+end

data/lib/html_processor.rb

@@ -0,0 +1,106 @@
+require 'redcarpet'
+require 'nokogiri'
+require 'sanitize'
+
+# This utility class is used to
+# work on html text
+#
+# You can initialize it with html or markdown text
+class HtmlProcessor
+  attr_reader :html, :original
+  
+  #======================================
+  # Constants
+  #======================================
+  DESCRIPTION_PROCESSING_ORDER = %w( p h1 h2 h3 h4 h5 h6 )
+  
+  
+  # Define Youtube transformer for Sanitize
+  YOUTUBE_TRANSFORMER = lambda do |env|
+    node      = env[:node]
+    node_name = env[:node_name]
+
+    # Don't continue if this node is already whitelisted or is not an element.
+    return if env[:is_whitelisted] || !node.element?
+
+    # Don't continue unless the node is an iframe.
+    return unless node_name == 'iframe'
+
+    # Verify that the video URL is actually a valid YouTube video URL.
+    return unless node['src'] =~ %r|\A(?:https?:)?//(?:www\.)?youtube(?:-nocookie)?\.com/|
+
+    # We're now certain that this is a YouTube embed, but we still need to run
+    # it through a special Sanitize step to ensure that no unwanted elements or
+    # attributes that don't belong in a YouTube embed can sneak in.
+    Sanitize.node!(node, {
+      :elements => %w[iframe],
+
+      :attributes => {
+        'iframe'  => %w[allowfullscreen frameborder height src width]
+      }
+    })
+
+    # Now that we're sure that this is a valid YouTube embed and that there are
+    # no unwanted elements or attributes hidden inside it, we can tell Sanitize
+    # to whitelist the current node.
+    {:node_whitelist => [node]}
+  end
+  
+  # Default options for Sanitize
+  SANITIZER_OPTS = Sanitize::Config::RELAXED.merge(
+    attributes: Sanitize::Config::RELAXED[:attributes].merge(
+      'a' => %w[href hreflang name rel target],
+    ),
+    transformers: YOUTUBE_TRANSFORMER
+  )
+  
+  #======================================
+  # Methods
+  #======================================
+  def initialize(text, options = { })
+    @original = text
+    
+    # Process markdown or leave original
+    if options[:format].to_s == 'markdown' && text
+      html_options = { :safe_links_only => true, :hard_wrap => true, :filter_html => false }
+      renderer_options = { :autolink => true, :no_intraemphasis => true, :fenced_code_blocks => true, :superscript => true }
+      
+      renderer = Redcarpet::Markdown.new(Redcarpet::Render::HTML.new(html_options), renderer_options)
+      raw_html = renderer.render(text)
+      @html = Sanitize.fragment(raw_html, SANITIZER_OPTS)
+    else
+      @html = text
+    end
+  end
+  
+  # Return a Nokogiri document based
+  # on processor html
+  def document
+    @document ||= Nokogiri::HTML(@html)
+  end
+  
+  # Return a description of the document
+  # by returning the first sentence of the
+  # first DESCRIPTION_PROCESSING_ORDER found
+  def description
+    # Return cached value if one
+    return @description if @description
+    
+    # Parse the html document to try to find
+    # a description
+    @description = ''
+    DESCRIPTION_PROCESSING_ORDER.each do |selector|
+      elem = self.document.css(selector).select { |e| e && !e.content.blank? }.first
+      next if elem.blank? #skip if nil or empty
+      
+      # Try to get the first two sentences
+      match = elem.content.match(/([^.!?]+[.!?]?)([^.!?]+[.!?]?)?/)
+      if match && match.captures.any?
+        @description = match.captures.compact.join('')
+      end
+      break if !@description.empty?
+    end
+    
+    return @description
+  end
+end