hippo-fw 0.9.1

data/lib/hippo/spec_helper.rb

@@ -0,0 +1,141 @@
+require 'rack/test'
+require 'hippo'
+require 'hippo/api'
+require 'hashie/mash'
+require 'active_record'
+require 'active_record/fixtures'
+require 'rack/test'
+require 'mail'
+require 'factory_girl'
+require 'faker'
+require 'database_cleaner'
+require "shrine/storage/memory"
+require 'vcr'
+
+VCR.configure do |config|
+    config.cassette_library_dir = "spec/fixtures/vcr_cassettes"
+    config.hook_into :webmock
+    config.configure_rspec_metadata!
+end
+
+Hippo::Concerns::AssetUploader.storages = {
+    cache: Shrine::Storage::Memory.new,
+    store: Shrine::Storage::Memory.new,
+}
+
+VCR_OPTS = {
+    record: ENV["VCR_RECORD"].try(:to_sym) || :none, # This should default to :none before pushing
+    allow_unused_http_interactions: false
+}
+
+
+module RackSpecMixin
+  include Rack::Test::Methods
+  def app
+      Hippo::API::Root
+  end
+  def last_response_json
+      Oj.load(last_response.body)
+  end
+end
+
+HIPPO_ENV = "test"
+module Fixtures
+    def fixtures_path
+        Hippo::Extensions.controlling.root_path.join('spec', 'fixtures')
+    end
+end
+
+RSpec.configure do |config|
+    config.include FactoryGirl::Syntax::Methods
+
+    config.include Fixtures
+
+    config.include RackSpecMixin, :api => true
+
+    # Use color in STDOUT
+    config.color = true
+
+    config.before(:suite) do
+        FactoryGirl.find_definitions
+        DatabaseCleaner.strategy = :transaction
+    end
+
+    config.around(:each) do |example|
+        DatabaseCleaner.cleaning do
+            example.run
+        end
+    end
+
+    # rspec-expectations config goes here. You can use an alternate
+    # assertion/expectation library such as wrong or the stdlib/minitest
+    # assertions if you prefer.
+    config.expect_with :rspec do |expectations|
+        # This option will default to `true` in RSpec 4. It makes the `description`
+        # and `failure_message` of custom matchers include text for helper methods
+        # defined using `chain`, e.g.:
+        #     be_bigger_than(2).and_smaller_than(4).description
+        #     # => "be bigger than 2 and smaller than 4"
+        # ...rather than:
+        #     # => "be bigger than 2"
+        expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+    end
+
+    # rspec-mocks config goes here. You can use an alternate test double
+    # library (such as bogus or mocha) by changing the `mock_with` option here.
+    config.mock_with :rspec do |mocks|
+        # Prevents you from mocking or stubbing a method that does not exist on
+        # a real object. This is generally recommended, and will default to
+        # `true` in RSpec 4.
+        mocks.verify_partial_doubles = true
+    end
+
+    # The settings below are suggested to provide a good initial experience
+    # with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

data/lib/hippo/strings.rb

@@ -0,0 +1,56 @@
+module Hippo
+
+    module Strings
+
+        # list of characters that should not be used
+        BAD_RAND_CHARS  = %w{ B 8 o O 0 i l I 1 }
+
+        # characters that should be randomly chosen from
+        RAND_CHARS = ( ('A'..'Z').to_a + ('a'..'z').to_a + ('0'..'9').to_a ) - BAD_RAND_CHARS
+
+        # Generates a random string without using commonly confused numbers and letters.
+        # It's intended for use in situations where the code will have to be
+        # read and re-entered later.
+        #
+        # The characters in BAD_RAND_CHARS are avoided since they can be confused with one another:
+        # @return [String] a random string <length> characters long.
+        def self.random( length = 12 )
+            1.upto(length).each_with_object(''){|i,s| s << RAND_CHARS[ rand(RAND_CHARS.length) ] }
+        end
+
+        # Attempts to shorten a string while keeping it somewhat
+        # like it's original self.
+        # Useful for suggesting a code for a given entity name.
+        # @param string [String] the string to shorten.
+        # @param length [Integer] how long the returned code should be
+        # @param padding [String] What to pad the code with if it is shorter than length.  False indicates no padding should be performed
+        # @return [String] a shortened version of the name with:
+        #  * Upper cased
+        #  * Spaces stripped
+        #  * Made up of a proportional number of chars from each word
+        # #### Examples:
+        #     Hippo::Strings.to_code_identifier('General Acme Corp')       #=> 'GENACMCORP'
+        #     Hippo::Strings.code_identifier('General I B', padding:false) #=> 'GENERALIB' *(no trailing X)*
+        #     Hippo::Strings.to_code_identifier('Top Cat', maxlen: 5 )     #=> 'TOCAT'
+        def self.code_identifier( string, length:10, padding: 'X' )
+            stripped = string.gsub(/\W/, '').upcase
+            if stripped.length < length
+                return padding.present? ? stripped.ljust( length, padding ) : stripped
+            end
+            result = ''
+            words = string.gsub(/[^\w\s-]/,'').split(/\s+|-|_/)
+            0.upto(words.length + 1).each_with_index do | attempt_num |
+                remainder = length
+                result = ''
+                string = words.each_with_index do | word, index |
+                    chars = ( remainder / (words.length-index) + attempt_num )
+                    result << word[0...chars]
+                    remainder = length - result.length
+                end
+                break if result.length >= length
+            end
+            result[0...length].upcase
+        end
+
+    end
+end

data/lib/hippo/system_settings.rb

@@ -0,0 +1,72 @@
+module Hippo
+
+    class SystemSettings < Hippo::Model
+
+        has_one :logo, as: :owner, class_name: 'Hippo::Asset',
+                dependent: :destroy
+
+        has_one :print_logo,  -> { where owner_type: "SecondaryPhoto"},
+                class_name: 'Hippo::Asset', foreign_key: :owner_id,
+                foreign_type: :owner_type,
+                dependent: :destroy
+
+        class ExtensionSettings < OpenStruct
+            def initialize(ext_id, settings)
+                @extension_id = ext_id
+                super(settings)
+            end
+            def persist!
+                SystemSettings.persist!(@extension_id, self.to_h)
+            end
+        end
+
+        after_commit :notify_updated, on: :update
+        def notify_updated
+            Hippo.redis_connection.publish('hippo-system-configuration-update', self.id)
+        end
+
+        def for_ext(extension_id)
+            ExtensionSettings.new(extension_id, settings[extension_id.to_s])
+        end
+
+        class << self
+            def config
+                SystemSettings.first_or_create
+            end
+
+            def for_ext(extension_id)
+                config.for_ext(extension_id)
+            end
+
+            def persist!(extension_id, update)
+                config.settings[extension_id] = update
+                config.settings_will_change!
+                config.save!
+            end
+
+            def get_handler
+                Hippo::API::RequestWrapper.with_authenticated_user(
+                    role: 'administrator', with_transaction: false
+                ) do |user, req|
+                    req.std_api_reply :get,
+                                  Hippo::SystemSettings.config.as_json(
+                                      include: ['logo', 'print_logo']
+                                  )
+                end
+            end
+
+            def update_handler
+                Hippo::API::RequestWrapper.with_authenticated_user(
+                    role: 'administrator', with_transaction: false
+                ) do |user, req|
+                    config = SystemSettings.config
+                    if req.data['settings'].is_a?(Hash)
+                        config.update_attributes!(settings: req.data['settings'])
+                    end
+                    req.std_api_reply :update, { settings: config.settings }, success: true
+                end
+            end
+
+        end
+    end
+end

data/lib/hippo/templates/base.rb

@@ -0,0 +1,44 @@
+module Hippo
+
+    module Templates
+
+        class Base
+            include ::Hippo::Concerns::AttrAccessorWithDefault
+
+            class_attribute :defined_format
+
+            attr_accessor_with_default :extension_id
+
+            def self.format(fmt)
+                self.defined_format = fmt
+            end
+
+            def root_path
+                Hippo::Extensions.for_identifier(extension_id.to_s).root_path.join('templates')
+            end
+
+            def pathname
+                root_path.join(filename)
+            end
+
+            def class_as_name
+                self.class.to_s.demodulize.underscore
+            end
+
+            def filename
+                class_as_name + self.extension
+            end
+
+            def source
+                pathname.read
+            end
+
+            def extension
+                '.' + defined_format.to_s
+            end
+
+        end
+
+    end
+
+end

data/lib/hippo/templates/latex.rb

@@ -0,0 +1,101 @@
+require 'erb_latex'
+
+module Hippo
+
+    module Templates
+
+        class Latex < Base
+
+            ALL = []
+
+            def self.for_identifier(id)
+                ALL.find{|tmpl| tmpl.identifier == id}
+            end
+
+            class Context < ErbLatex::Context
+
+                def pluralize(count, word)
+                    count == 1 ? word : word.pluralize
+                end
+
+            end
+
+            attr_accessor_with_default :model
+            attr_accessor_with_default :identifier
+
+            def self.inherited(klass)
+                ALL << klass
+            end
+
+            attr_reader :id
+
+            def initialize(id)
+                @id = id
+            end
+
+            def as_pdf
+                engine.to_stringio
+            rescue ErbLatex::LatexError => e
+                Hippo.logger.warn e.log
+                raise
+            rescue => e
+                Hippo.logger.warn e
+                raise
+            end
+
+            def as_latex
+                engine.compile_latex
+            end
+
+            def root_path
+                super.join('latex')
+            end
+
+            def variables
+                { 'root_path' => root_path, class_as_name => record }
+            end
+
+            def record
+                @record ||= model.find(id)
+            end
+
+            def extension
+                '.tex.erb'
+            end
+
+            def render
+                engine.to_stringio
+            rescue ErbLatex::LatexError => e
+                Hippo.logger.warn e.log
+                raise
+            rescue => e
+                Hippo.logger.warn e
+                raise
+            end
+
+            def context
+                Context
+            end
+
+            def engine_options
+                options = {
+                    data: variables,
+                    context: context,
+                    partials_path: root_path.join('partials'),
+                    packages_path: root_path.join('packages')
+
+                }
+                options[:layout] = layout unless layout.blank?
+                options
+            end
+
+            def layout
+                root_path.join('layout.tex.erb')
+            end
+
+            def engine
+                ErbLatex::Template.new(pathname, engine_options)
+            end
+        end
+    end
+end

data/lib/hippo/templates/liquid.rb

@@ -0,0 +1,28 @@
+require 'liquid'
+
+module Hippo
+
+    module Templates
+
+        class Liquid < Base
+
+            def extension
+                '.liquid'
+            end
+
+            def render
+                template.render(variables.stringify_keys)
+            end
+
+            def variables
+                {}
+            end
+
+            def template
+                @template ||= ::Liquid::Template.parse(source, :error_mode => :warn)
+            end
+
+        end
+
+    end
+end