locomotivecms_steam 0.1.2.pre.beta → 1.0.0.pre.alpha

data/lib/locomotive/steam/services/entry_submission_service.rb

@@ -0,0 +1,91 @@
+require 'sanitize'
+
+module Locomotive
+  module Steam
+
+    class EntrySubmissionService < Struct.new(:content_type_repository, :repository, :locale)
+
+      include Locomotive::Steam::Services::Concerns::Decorator
+
+      def submit(slug, attributes = {})
+        type = get_type(slug)
+
+        return nil if type.nil?
+
+        clean_attributes(attributes)
+
+        build_entry(type, attributes) do |entry|
+          if validate(entry)
+            repository.create(entry)
+          end
+        end
+      end
+
+      def find(type_slug, slug)
+        type = get_type(type_slug)
+
+        return nil if type.nil?
+
+        i18n_decorate { repository.with(type).by_slug(slug) }
+      end
+
+      def to_json(entry)
+        return nil if entry.nil?
+
+        # default values
+        hash = { _slug: entry._slug, content_type_slug: entry.content_type_slug }
+
+        # dynamic attributes
+        entry.content_type.fields.all.each do |field|
+          next if %w(belongs_to has_many many_to_many).include?(field.type.to_s)
+
+          hash[field.name] = entry.send(field.name)
+        end
+
+        # errors
+        hash[:errors] = entry.errors.messages unless entry.errors.empty?
+
+        hash.to_json
+      end
+
+      private
+
+      def get_type(slug)
+        return nil if slug.blank?
+
+        content_type_repository.by_slug(slug)
+      end
+
+      def build_entry(type, attributes, &block)
+        i18n_decorate { repository.with(type).build(attributes) }.tap do |entry|
+          yield(entry)
+        end
+      end
+
+      def validate(entry)
+        # simple validations (existence of values) first
+        entry.valid?
+
+        # check if the entry has unique values for its
+        # fields marked as unique are really
+        content_type_repository.look_for_unique_fields(entry.content_type).each do |name, _|
+          if repository.with(entry.content_type).exists?(name => entry.send(name))
+            entry.errors.add(name, :unique)
+          end
+        end
+
+        entry.errors.empty?
+      end
+
+      def clean_attributes(attributes)
+        attributes.each do |key, value|
+          next unless value.is_a?(String)
+          attributes[key] = Sanitize.clean(value, Sanitize::Config::BASIC)
+        end
+      end
+
+    end
+
+  end
+end
+

data/lib/locomotive/steam/services/external_api_service.rb

@@ -0,0 +1,55 @@
+require 'uri'
+require 'httparty'
+
+module Locomotive
+  module Steam
+    class ExternalAPIService
+
+      include ::HTTParty
+
+      def consume(url, options = {})
+        options[:base_uri], path = extract_base_uri_and_path(url)
+
+        options.delete(:format) if options[:format] == 'default'
+
+        # auth ?
+        username, password = options.delete(:username), options.delete(:password)
+        options[:basic_auth] = { username: username, password: password } if username
+
+        perform_request_to(path, options)
+      end
+
+      private
+
+      def extract_base_uri_and_path(url)
+        url = HTTParty.normalize_base_uri(url)
+
+        uri       = URI.parse(url)
+        path      = uri.request_uri || '/'
+        base_uri  = "#{uri.scheme}://#{uri.host}"
+        base_uri  += ":#{uri.port}" if uri.port != 80
+
+        [base_uri, path]
+      end
+
+      def perform_request_to(path, options)
+        # [DEBUG] puts "[WebService] consuming #{path}, #{options.inspect}"
+
+        # sanitize the options
+        options[:format]  = options[:format].gsub(/[\'\"]/, '').to_sym if options.has_key?(:format)
+        options[:headers] = { 'User-Agent' => 'LocomotiveCMS' } if options[:with_user_agent]
+
+        response        = self.class.get(path, options)
+        parsed_response = response.parsed_response
+
+        if response.code == 200
+          HashConverter.to_underscore parsed_response
+        else
+          Locomotive::Common::Logger.error "[WebService] consumed #{path}, #{options.inspect}, response = #{response.inspect}"
+          nil
+        end
+      end
+
+    end
+  end
+end

data/lib/locomotive/steam/services/image_resizer_service.rb

@@ -0,0 +1,49 @@
+module Locomotive
+  module Steam
+
+    class ImageResizerService < Struct.new(:resizer, :asset_path)
+
+      IsHTTP = /^https?:\/\//o
+
+      def resize(source, geometry)
+        return nil if disabled? || geometry.blank?
+
+        if file = fetch_file(source)
+          file.thumb(geometry).url
+        else
+          Locomotive::Common::Logger.error "Unable to resize on the fly: #{source.inspect}"
+          nil
+        end
+      end
+
+      def disabled?
+        resizer.nil? || resizer.plugins[:imagemagick].nil?
+      end
+
+      protected
+
+      def fetch_file(source)
+        url_or_path = get_url_or_path(source)
+
+        if url_or_path =~ IsHTTP
+          resizer.fetch_url(url_or_path)
+        else
+          path = url_or_path.sub(/(\?.*)$/, '')
+          resizer.fetch_file(File.join(asset_path || '', 'public', path))
+        end
+      end
+
+      def get_url_or_path(source)
+        if source.is_a?(Hash)
+          source['url']
+        elsif source.respond_to?(:url)
+          source.url
+        else
+          source
+        end.strip
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/steam/services/liquid_parser_service.rb

@@ -0,0 +1,23 @@
+module Locomotive
+  module Steam
+
+    class LiquidParserService < Struct.new(:parent_finder, :snippet_finder)
+
+      def parse(page, events_listener = nil)
+        _parse(page,
+          page:             page,
+          events_listener:  events_listener,
+          parent_finder:    parent_finder,
+          snippet_finder:   snippet_finder,
+          parser:           self)
+      end
+
+      def _parse(object, options = {})
+        # Note: the template must not be parsed here
+        ::Liquid::Template.parse(object.liquid_source, options)
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/steam/services/markdown_service.rb

@@ -0,0 +1,17 @@
+require 'kramdown'
+
+module Locomotive
+  module Steam
+
+    class MarkdownService
+
+      def to_html(text)
+        return '' if text.blank?
+
+        Kramdown::Document.new(text, auto_ids: false).to_html
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/steam/services/no_cache_service.rb

@@ -0,0 +1,17 @@
+module Locomotive
+  module Steam
+
+    class NoCacheService
+
+      def fetch(key, options = {}, &block)
+        @last_response = block.call
+      end
+
+      def read(key)
+        nil
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/steam/services/page_finder_service.rb

@@ -0,0 +1,44 @@
+module Locomotive
+  module Steam
+
+    class PageFinderService < Struct.new(:repository)
+
+      include Locomotive::Steam::Services::Concerns::Decorator
+
+      def find(path)
+        decorate do
+          repository.by_fullpath(path)
+        end
+      end
+
+      def match(path)
+        decorate do
+          repository.matching_fullpath(path_combinations(path))
+        end
+      end
+
+      private
+
+      def path_combinations(path)
+        _path_combinations(path.split('/'))
+      end
+
+      def _path_combinations(segments, can_include_template = true)
+        return nil if segments.empty?
+        segment = segments.shift
+
+        (can_include_template ? [segment, WILDCARD] : [segment]).map do |_segment|
+          if (_combinations = _path_combinations(segments.clone, can_include_template && _segment != WILDCARD))
+            [*_combinations].map do |_combination|
+              File.join(_segment, _combination)
+            end
+          else
+            [_segment]
+          end
+        end.flatten
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/steam/services/parent_finder_service.rb

@@ -0,0 +1,23 @@
+require_relative 'page_finder_service'
+
+module Locomotive
+  module Steam
+
+    class ParentFinderService < PageFinderService
+
+      def find(page, fullpath)
+        return nil if fullpath.blank?
+
+        decorate do
+          if fullpath.strip == 'parent'
+            repository.parent_of(page)
+          else
+            repository.by_fullpath(fullpath)
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/steam/services/site_finder_service.rb

@@ -0,0 +1,13 @@
+module Locomotive
+  module Steam
+
+    class SiteFinderService < Struct.new(:repository, :request)
+
+      def find
+        repository.by_domain(request.host)
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/steam/services/snippet_finder_service.rb

@@ -0,0 +1,17 @@
+module Locomotive
+  module Steam
+
+    class SnippetFinderService < Struct.new(:repository)
+
+      include Locomotive::Steam::Services::Concerns::Decorator
+
+      def find(slug)
+        decorate do
+          repository.by_slug(slug)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/steam/services/textile_service.rb

@@ -0,0 +1,17 @@
+require 'RedCloth'
+
+module Locomotive
+  module Steam
+
+    class TextileService
+
+      def to_html(text)
+        return '' if text.blank?
+
+        ::RedCloth.new(text).to_html
+      end
+
+    end
+
+  end
+end

data/lib/locomotive/steam/services/theme_asset_url_service.rb

@@ -0,0 +1,43 @@
+module Locomotive
+  module Steam
+
+    class ThemeAssetUrlService < Struct.new(:repository, :asset_host, :checksum)
+
+      def build(path)
+        # keep the query string safe
+        path.gsub!(/(\?+.+)$/, '')
+        query_string = $1
+
+        # build the url of the theme asset based on the persistence layer
+        _url = repository.url_for(path)
+
+        # get a timestamp only the source url does not include a query string
+        timestamp = query_string.blank? ? checksums[path] : nil
+
+        # prefix by a asset host if given
+        url = asset_host ? asset_host.compute(_url, timestamp) : _url
+
+        query_string ? "#{url}#{query_string}" : url
+      end
+
+      def checksums
+        if checksum?
+          @checksums ||= fetch_checksums
+        else
+          {}
+        end
+      end
+
+      def checksum?
+        !!checksum
+      end
+
+      private
+
+      def fetch_checksums
+        repository.checksums
+      end
+
+    end
+  end
+end

data/lib/locomotive/steam/services/translator_service.rb

@@ -0,0 +1,34 @@
+module Locomotive
+  module Steam
+
+    class TranslatorService < Struct.new(:repository, :current_locale)
+
+      # Return the translation described by a key.
+      #
+      # @param [ String ] key The key of the translation.
+      # @param [ String ] locale The locale we want the translation in
+      # @param [ String ] scope If specified, instead of looking in the translations, it will use I18n instead.
+      #
+      # @return [ String ] the translated text or nil if not found
+      #
+      def translate(input, locale, scope = nil)
+        locale ||= self.current_locale
+
+        if scope.blank?
+          values = repository.by_key(input).try(:values) || {}
+
+          if translation = values[locale.to_s]
+            translation
+          else
+            Locomotive::Common::Logger.warn "Missing translation '#{input}' for the '#{locale}' locale".yellow
+            input
+          end
+        else
+          I18n.t(input, scope: scope.split('.'), locale: locale)
+        end
+      end
+
+    end
+
+  end
+end