blix-assets 0.1.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5ae57089bbdbcfd6502c2d9971c8426586255a4741ea496203b583450ba8e9ae
+  data.tar.gz: e8a0acfb4dcc36a8f19825ddf1076ac205359e3e6e29e6b89f4836500f6a4761
+SHA512:
+  metadata.gz: a31cfcb6ae272fea115afdffc9799b226633c123edd8b7e24d03048742f8691789649fd2635e75336c0c9fdb2ddeb33f5c4be46d3b8b1131bf32ec920f58fa77
+  data.tar.gz: 4e68d177b42d011ab740d23e7dd5068cc045f37a1f4cdd61846aae6fb36b1db909c6d0cfffac89c42092610df1b028d9cd542925e84a7d8cb09425a9ba67f0ab

data/LICENSE

@@ -0,0 +1,25 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Clive Andrews
+
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,127 @@
+## INSTALLATION
+
+    gem install blix-assets
+
+
+## Manage Asset Files
+
+#### using the asset pipeline
+
+the assets are served by your asset pipeline ( sprockets) and the link to the asset in your html
+is the asset name pure and simple.
+
+eg:
+
+     <script src="/assets/application.js" type="text/javascript"></script>
+
+#### using compiled assets
+
+a hash is added to the asset name to ensure that it is unique. This allows the asset to be cached indefinitely on the
+browser.
+
+   eg:
+
+     <script src="/assets/application-59D3331242D65ECC.js" type="text/javascript"></script>
+
+#### template helper
+
+in order to use the relevant version user the *asset_path* helper in you template. The PRODUCTION flag should indicate
+if you are in development mode (false) or in production mode/compiled assets mode (true).
+
+    eg:
+
+    <script src="<%= Blix::AssetManager.asset_path('/assets/application.js',PRODUCTION) %>" type="text/javascript"></script>
+
+    <%= Blix::AssetManager.asset_tag('/assets/application.js',PRODUCTION) %>
+
+    <%= Blix::AssetManager.asset_tag('/assets/main.css',PRODUCTION, :media=>'screen') %>
+
+if you are using blix_rest then there is a helper defined ..
+
+    <script src="<%= asset_path('/assets/application.js') %>" type="text/javascript"></script>
+
+or the complete tag ..
+
+    <%= asset_tag('/assets/application.js') %>
+
+    <%= asset_tag('/static/man.css', :media=>'screen') %>
+
+to enable this helper you have to `require 'blix/rest'` first and then `require 'blix/assets'`
+
+##### inline assets
+
+assets can also be inlined which results in the contents of the compiled
+assets to be inlined in *production* mode only.
+
+In development mode a link to the asset is used.
+
+     <%= asset_tag('/assets/application.js', :inline=>true ) %>
+
+     <%= asset_tag('/static/main.css', :media=>'screen', :inline=>true) %>
+
+## Mount points in templates
+
+  use the following helpers to expand any filenames to include a mount point
+  in your templates.
+
+  Blix::AssetManager.set_path_root( '/myapp')
+
+  Blix::AssetManager.full_path('/images/icon.png')  ==> '/myapp/images/icon.png'
+
+## Compiling Assets
+
+  ensure that the destination dictory exists and that the config directory
+  'config/assets' also exists !!
+
+  For the destination directory use a path relative to your applications working directory.
+
+  This will ensure that the file can be found in your production environment as well as in your
+  development environment.
+
+    require 'blix/assets'
+
+    DEST = File.join("www","assets")  # where the asset is to be written
+
+    data = environment[name].to_s          # the compiled asset data
+
+    Blix::AssetManager.write_asset(DEST,"application.js",data)
+
+  it is also possible to force a version number on the asset instead of a generated stamp
+
+    Blix::AssetManager.write_asset(DEST,"application.js",data, :version=>"1.2.3")
+
+
+## Generate a static index.html
+
+it is possible to generate a static index.html with the correct assets within your asset compile script.
+
+you will need an index.html.erb file with the  <%= Blix::AssetManager.asset_tag .. %> code
+
+and set your PRODUCTION variable to true in the compile script. In your config.ru set PRODUCTION to false in
+development mode.
+
+eg ...
+
+index.html.erb
+
+    ....
+    ....
+    <head>
+        <%= Blix::AssetManager.asset_tag('/assets/application.js',PRODUCTION) %>
+        <%= Blix::AssetManager.asset_tag('/assets/main.css',PRODUCTION, :media=>'screen') %>
+
+    </head>
+
+compile_assets.rb ..
+
+    ROOT = Dir.pwd
+    PRODUCTION = true
+    DEST = File.join("www","assets")
+    ....
+    ....
+    Blix::AssetManager.write_asset(DEST,"application.js",environment["application.js"].to_s)
+    Blix::AssetManager.write_asset(DEST,"main.css",environment["main.css"].to_s)
+    ....
+    ....
+
+    File.write File.join("www","index.html"),environment['index.html'].to_s

data/lib/blix/assets.rb

@@ -0,0 +1,20 @@
+require 'blix/assets/asset_manager'
+
+# add the asset_path method to the Controller if it is being used.
+if defined? Blix::Rest
+  module Blix
+    module Rest
+      class Controller
+        def asset_path(partial_path)
+          AssetManager.asset_path(full_path(partial_path),mode_production?)
+        end
+        
+        # make a complete html tag for an asset
+        def asset_tag(partial_path,opts={})
+            AssetManager.asset_tag(full_path(partial_path),mode_production?,opts)
+        end
+        
+      end
+    end
+  end
+end

data/lib/blix/assets/asset_manager.rb

@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+# manage your asset names
+#
+# a config directory contains a file for each managed asset using its generic name. In the file
+# is the unique stamp that is used to find the name of the latest version of the asset.
+# config format consists of a filestamp part and md5 hash part
+#
+# ensure that your config dir exists (default config/assets)
+# ensure that you destination dir exists ( eg public/assets )
+#
+#  then use something like this to compile your assets...
+#
+# ASSETS = ['main.js', 'main.css']
+# ASSETS.each do |name|
+#
+#   str = environment[name].to_s
+#
+#   if File.extname(name) == ".css"
+#     engine = Sass::Engine.new(str, :syntax => :scss, :style => :compressed)
+#     str = engine.render
+#   end
+#
+#   AssetManager.if_modified(name,str,:rewrite=>true) do |a|
+#
+#     filename = File.join(ROOT,"www","assets",a.newname)
+#     puts "writing #{name} to #{filename}"
+#     File.write filename,str
+#
+#     File.unlink File.join(ROOT,"www","assets",a.oldname) if a.oldname
+#   end
+#
+# end
+#
+#
+# then within your erb template or whatever ...
+#
+# <script src="<%= AssetManager.asset_path('/assets/main.js',flag) %>" type="text/javascript"></script>
+#
+# where flag indicates if the static compiled version should be used ( ie with hash) or the plain name ( served by sprockets pipeline)
+
+module Blix
+  class AssetManager
+
+    AssetInfo = Struct.new(:newname, :oldname)
+    class << self
+
+      def config_dir
+        @config_dir || 'config/assets'
+      end
+
+      attr_writer :config_dir
+
+      # the name of the file to write to
+      def filename(name)
+        name
+      end
+
+      def asset_root
+        @asset_root || 'assets'
+      end
+
+      attr_writer :asset_root
+
+      # write the compiled asset here
+      def dest_path(name)
+        File.join(asset_dir, filename(name))
+      end
+
+      # write the config info here
+      def config_path(name)
+        File.join(config_dir, filename(name) + '.conf')
+      end
+
+      # yield the old and new name to a block if
+      # the asset has been modified
+      def if_modified(destination, name, data, opts = {})
+        new_hash = Digest::MD5.hexdigest data
+
+        ext = File.extname(name)[1..-1]
+        base = name.split('.')[0]
+        confname = base + '.' + ext
+        config = get_config(confname)
+
+        if !config ||
+           (config[:hash] != new_hash || (config[:destination] != destination)) ||
+           opts[:version] && (opts[:version] != config[:version])
+
+          stamp = get_filestamp
+          info = AssetInfo.new
+          info.newname = "#{base}-#{opts[:version] || stamp}.#{ext}"
+          info.oldname = config && "#{base}-#{config[:version] || config[:stamp]}.#{ext}"
+          set_config(destination, confname, new_hash, stamp, opts[:version])
+          yield(info)
+
+        elsif opts[:rewrite] # rewrite the same data to the same asset as before
+
+          info = AssetInfo.new
+          info.newname = config && "#{base}-#{config[:version] || config[:stamp]}.#{ext}"
+          info.oldname = nil
+          yield(info)
+
+        end
+      end
+
+      # generate a unique suffix for the file
+      def get_filestamp
+        now = Time.now
+        str = '%X' % now.to_i
+        str += '%X' % now.usec
+        str += '%X' % rand(9999)
+        str
+      end
+
+      # get config data from file or nil if file does not exist
+      def get_config(name)
+        return nil unless File.exist? config_path(name)
+
+        data = File.read config_path(name)
+        parts = data.split('|')
+        out = { :hash => parts[1], :stamp => parts[0], :destination => parts[3] }
+        out[:version] = parts[2] unless parts[2].empty?
+        out
+      end
+
+      # set the config data
+      def set_config(destination, name, hash, stamp, version = nil)
+        File.write(config_path(name), stamp + '|' + hash + '|' + version.to_s + '|' + destination)
+        true
+      end
+
+      # cache asset name store
+      def cache
+        @cache ||= {}
+      end
+
+      # retrieve and cache the full asset name
+      def get_asset_name(name)
+        cache[name] ||= begin
+          config = get_config(name)
+          raise "ERROR : config file for asset:#{name} not found !!" unless config
+
+          ext = File.extname(name)[1..-1]
+          base = name.split('.')[0]
+          base + '-' + (config[:version] || config[:stamp]) + '.' + ext
+        end
+      end
+
+      # retrieve and cache the full asset name
+      def get_asset_version_name(name)
+        cache[name] ||= begin
+          config = get_config(name)
+          raise "ERROR : config file for asset:#{name} not found !!" unless config
+
+          ext = File.extname(name)[1..-1]
+          base = name.split('.')[0]
+          base + '-' + config[:version] + '.' + ext
+        end
+      end
+
+      def set_path_root(root)
+        root = root.to_s
+        root = '/' + root if root[0, 1] != '/'
+        root += '/' if root[-1, 1] != '/'
+        @path_root = root
+        @path_root_length = @path_root.length - 1
+      end
+
+      def path_root
+        @path_root || '/'
+      end
+
+      attr_reader :path_root_length
+
+      # calculate the full path of the asset
+      def full_path(path)
+        path = path[1..-1] if path[0, 1] == '/'
+        path_root + path
+      end
+
+      # caculate the correct asset path depending on the mode of execution
+      def asset_path(path, mode_production = false)
+        partial_path = full_path(path)
+        if mode_production
+          asset_name = File.basename(partial_path)
+          dir_name = File.dirname(partial_path)
+          if dir_name == '.'
+            AssetManager.get_asset_name(asset_name)
+          else
+            File.join(dir_name, AssetManager.get_asset_name(asset_name))
+          end
+        else
+          partial_path
+        end
+      end
+
+      # return the location of the compiled asset
+      def file_path(path)
+        name = File.basename(path)
+        config = get_config(name)
+        raise "ERROR : config file for asset:#{name} not found !!" unless config
+
+        ext = File.extname(name)[1..-1]
+        base = name.split('.')[0]
+        config[:destination] + '/' + base + '-' + (config[:version] || config[:stamp]) + '.' + ext
+      end
+
+      # write a complete asset tag html string
+      def asset_tag(partial_path, mode_production = false, opts = {})
+        name = File.basename(partial_path)
+        type = File.extname(partial_path)
+        inline = opts.delete(:inline)
+        opts_str = opts.to_a.map { |v| "#{v[0]}=\"#{v[1]}\"" }.join(' ')
+
+        if type == '.css'
+          if mode_production && inline
+            content = cache['///' + name] ||= File.read(file_path(partial_path))
+            %(<style type="text/css" #{opts_str} >\n#{content}</style>)
+          else
+            %(<link rel="stylesheet" href="#{asset_path(partial_path, mode_production)}" type="text/css" #{opts_str} >)
+          end
+        elsif type == '.js'
+          if mode_production && inline
+            # insert js here if in production mode
+            content = cache['///' + name] ||= File.read(file_path(partial_path))
+            %(<script>\n#{content}</script>)
+          else
+            %(<script src="#{asset_path(partial_path, mode_production)}" type="text/javascript"></script>)
+          end
+        else
+          raise "unknown tag for file extension:#{partial_path}"
+        end
+      end
+
+      # write an asset to the destination directory
+      def write_asset(destination, name, str, opts = {})
+        opts = opts.dup
+        opts[:rewrite] = true unless opts.key?(:rewrite)
+        raise "asset destination directory must exist:#{destination}" unless Dir.exist?(destination)
+
+        puts "#{red('WARNING !')} Use a relative path to the destination directory" if destination[0] == '/' # with colour red
+        if_modified(destination, name, str, opts) do |a|
+          outfile = File.join(destination, a.newname)
+          File.write outfile, str
+          if a.oldname && (a.oldname != a.newname)
+            oldfilename = File.join(destination, a.oldname)
+            File.unlink oldfilename if File.exist?(oldfilename)
+          end
+          outfile
+        end
+      end
+
+      private
+
+      # escape text for printing in red on console.
+      def red(text)
+        "\e[31m#{text}\e[0m"
+      end
+
+    end
+
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: blix-assets
+version: !ruby/object:Gem::Version
+  version: 0.1.5
+platform: ruby
+authors:
+- Clive Andrews
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-08-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Basic Routines for managing Compiled Assets
+email:
+- gems@realitybites.eu
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE
+files:
+- LICENSE
+- README.md
+- lib/blix/assets.rb
+- lib/blix/assets/asset_manager.rb
+homepage: https://github.com/realbite/blix-rest
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key: 
+specification_version: 4
+summary: Basic Asset Management Routines
+test_files: []