shoperb-theme-editor 0.8.0

data/lib/shoperb_theme_editor/mounter.rb

@@ -0,0 +1,30 @@
+module Shoperb module Theme module Editor
+  module Mounter
+
+    Editor.autoload_all self, "mounter"
+
+    module Model
+
+      def self.console
+        binding.pry
+      end
+
+      Editor.autoload_all self, "mounter/models"
+    end
+
+    def self.start
+      Rack::Handler::WEBrick.run(Server.new,
+        Port: Editor["port"],
+        AccessLog: [],
+        Logger: WEBrick::Log::new(Os["/dev/null"], 7),
+        StartCallback: -> {
+           Logger.success "Server started\nBrowse http://0.0.0.0:#{Editor["port"]}\n"
+        }
+      )
+    rescue Errno::EADDRINUSE => e
+      Logger.error e.message
+      exit!
+    end
+
+  end
+end end end

data/lib/shoperb_theme_editor/os.rb

@@ -0,0 +1,13 @@
+module Shoperb module Theme module Editor
+  module Os
+    REPLACEMENTS = {
+      "/dev/null" => {
+        /mswin|mingw/ => "NUL:"
+      }
+    }
+
+    def self.[] key
+      (REPLACEMENTS[key].detect { |k,v| k =~ RUBY_PLATFORM } || [])[1] || key
+    end
+  end
+end end end

data/lib/shoperb_theme_editor/package.rb

@@ -0,0 +1,81 @@
+require 'artisans'
+
+module Shoperb module Theme module Editor
+  module Package
+
+    extend self
+
+    def unzip file
+      Zip::File.open(file.path) { |zip_file|
+        spec = zip_file.glob("*/config/spec.json").first
+        if spec && (spec_content = zip_file.read(spec).presence)
+          zip_handle = Editor.handle(spec_content)
+        else
+          zip_handle = Editor["handle"] = zip_file.entries.first.name.split("/").first
+        end
+
+        # remove old files, which are not present in theme zip anymore
+        # but only from folders, mentioned in zip
+        zip_files   = zip_file.entries.map{|f| f.to_s.gsub(/^#{zip_handle}\//, '') }
+        zip_folders = zip_files.map{|f| f.split('/')[0] }.uniq
+        files_to_remove = Dir.glob("{#{zip_folders.join(',')}}/**/*.*") - zip_files
+
+        zip_file.each do |entry|
+          entry_name = Pathname.new(entry.name).cleanpath.to_s
+          name = entry_name.gsub(/\A#{zip_handle}\//, "")
+          extract_path = Utils.base + name
+          FileUtils.mkdir_p extract_path.dirname
+          Logger.notify "Extracting #{name}" do
+            entry.extract(extract_path) { true }
+          end
+        end
+        files_to_remove.each { |f| File.delete(f) }
+      }
+    ensure
+      Utils.rm_tempfile file
+    end
+
+    def zip
+      compiler = Editor.compiler("/system/assets/#{Editor["oauth-site"]}/#{Editor.handle}/", digests: true)
+
+      zip = Zip::OutputStream.write_buffer do |out|
+        compiler.compiled_files do |path, content, type = :file|
+          case type
+            when :symlink
+              write_symlink(out, path, content)
+            else
+              write_file(out, path) { content }
+          end
+        end
+      end
+      Utils.write_file("debug.zip") { zip.string } if Editor["verbose"]
+      Utils.mk_tempfile zip.string, "#{handle.basename}-", ".zip"
+    end
+
+    def write_file out, file
+      out.put_next_entry(zip_file_path = handle + file)
+      content = block_given? ? yield : file.read
+      if file.to_s[0..6] == "sources"
+        out.write content
+      else
+        Logger.notify "Packing #{file}" do
+          out.write content
+        end
+      end
+    end
+
+    def write_symlink out, current, target
+      entry = out.put_next_entry(zip_file_path = handle + current)
+      entry.instance_variable_set("@ftype", :symlink)
+      entry.instance_variable_set("@filepath", target.to_s)
+      Logger.notify "Packing #{current}" do
+        out.write((handle + target).relative_path_from(handle + current).to_s[3..-1])
+      end
+    end
+
+    def handle
+      Pathname.new(Editor.handle)
+    end
+
+  end
+end end end

data/lib/shoperb_theme_editor/sync/images.rb

@@ -0,0 +1,69 @@
+module Shoperb module Theme module Editor
+  module Sync
+    module Images
+
+      extend self
+      mattr_accessor :queue
+      self.queue = []
+
+      mattr_accessor :dir
+      self.dir = Utils.base + "data" + "assets" + "images"
+
+      def process
+        FileUtils.mkdir_p(dir)
+        Sync.process Mounter::Model::Image do |image|
+          if image["entity_id"]
+            process_sizes(image)
+            image
+          end
+        end
+        threaded_download "Downloading images"
+      end
+
+      private
+
+      def process_sizes image
+        image["sizes"] = image["sizes"].select{|size,url|url}.map do |size, url|
+          filename = filename_from_url(url)
+          enqueue_download(url, filename)
+          [size, filename.relative_path_from(dir).to_s]
+        end.compact.to_h
+      end
+
+      def filename_from_url url
+        dir + "#{Pathname.new(url).basename.to_s.split("?")[0]}"
+      end
+
+      def enqueue_download url, filename
+        (queue << -> {
+          begin
+            Utils.write_file(filename) do
+              begin
+                Timeout::timeout(10) do
+                  URI(url).open.read
+                end
+              rescue Timeout::Error => e
+                retry
+              end
+            end
+          rescue Exception => e
+            Logger.error("#{e.message} (#{url} => #{filename})")
+          end
+        }) unless File.exist?(filename)
+      end
+
+      def threaded_download message
+        return unless queue.any?
+        Logger.info message
+        Logger.notify message do
+          current, count = 0, 10
+          queue.each_slice(count) do |dls|
+            current = current + count
+            Logger.info "#{message} #{Sync.counter[current - count, [current, queue.count].min, queue.count]}\r"
+            dls.map { |block| Thread.new(&block) }.map(&:join)
+          end
+        end
+      end
+    end
+  end
+end end end

data/lib/shoperb_theme_editor/sync/pagination.rb

@@ -0,0 +1,52 @@
+module Shoperb module Theme module Editor
+  module Sync
+    Pagination = Struct.new("Pagination", :response) do
+
+      def total
+        pagination["total"]
+      end
+
+      def limit
+        pagination["limit"]
+      end
+
+      def offset
+        pagination["offset"]
+      end
+
+      def to
+        [total, next_page * limit].min
+      end
+
+      def page
+        offset / limit + 1
+      end
+
+      def next_page
+        page + 1
+      end
+
+      def present?
+        response && header && total && offset && limit && next_page <= last_page
+      end
+
+      def last_page
+        (total.to_f / limit).ceil
+      end
+
+      def message
+        yield(offset + limit, to, total)
+      end
+
+      private
+
+      def pagination
+        JSON.parse(header)
+      end
+
+      def header
+        response.headers["x-pagination"]
+      end
+    end
+  end
+end end end

data/lib/shoperb_theme_editor/sync.rb

@@ -0,0 +1,229 @@
+require 'open-uri'
+
+module Shoperb module Theme module Editor
+  module Sync
+    extend self
+
+    Editor.autoload_all self, "sync"
+
+    def vendors
+      process Mounter::Model::Vendor do |vendor|
+        vendor.delete("image")
+        vendor
+      end
+    end
+
+    def collections
+      process Mounter::Model::Collection
+    end
+
+    def countries
+      process Mounter::Model::Country
+    end
+
+    def states
+      process Mounter::Model::State do |state|
+        assign_relation state, Mounter::Model::Country
+        state
+      end
+    end
+
+    def pages
+      process Mounter::Model::Page
+    end
+
+    def blog_posts
+      process Mounter::Model::BlogCategory, 'blog-categories'
+      process Mounter::Model::BlogPost
+    end
+
+    def media_files
+      process Mounter::Model::MediaFile
+    end
+
+    def media_files
+      process Mounter::Model::MediaFile
+    end
+
+    def addresses(customer_ids)
+      process Mounter::Model::Address, where: "type:AddressWarehouse|AddressShop|AddressVendor|AddressSupplier"
+      lookup = "type:AddressCustomer"
+      if customer_ids.present?
+        lookup = "owner_type:Customer,owner_id:#{customer_ids}"
+      end
+      process Mounter::Model::Address, where: lookup
+    end
+
+    def images
+      Images.process
+    end
+
+    def menus
+      process Mounter::Model::Menu
+    end
+
+    def links
+      process Mounter::Model::Link do |link|
+        assign_relation link, Mounter::Model::Menu
+        link
+      end
+    end
+
+    def variants(ids)
+      process Mounter::Model::Variant, **product_ids_lookup(ids) do |variant|
+        assign_relation variant, Mounter::Model::Product
+        variant
+      end
+    end
+
+    def variant_attributes
+      variant_ids = Mounter::Model::Variant.select_map(:id)
+
+      klass  = Mounter::Model::VariantAttribute
+      path   = klass.to_s.demodulize.tableize
+      opts   = {}
+      result = []
+
+      variant_ids.each_slice(50) do |list|
+        opts[:variant_id] = list
+        result += fetch("api/v1/#{path}", **opts).compact
+      end
+      uniq = result.uniq { |h| h[klass.primary_key.to_s] }
+      Logger.info "Received #{result.count} #{path.pluralize(result.count)}, kept #{uniq.count}.\n" if Editor["verbose"]
+      klass.assign uniq.map(&:to_hash)
+    end
+
+    def products(ids)
+      lookup = {}
+      lookup = {where: "id:#{ids}"} if ids.present?
+      process Mounter::Model::ProductType
+      process Mounter::Model::Category
+      process Mounter::Model::Product, **lookup do |product|
+        assign_relation product, Mounter::Model::Category
+        assign_relation product, Mounter::Model::ProductType
+        assign_relation product, Mounter::Model::Vendor
+        product.delete("images")
+        product
+      end
+      product_attributes(ids)
+      variants(ids)
+      variant_attributes
+    end
+
+    def product_attributes(ids)
+      process Mounter::Model::AttributeKey
+      process Mounter::Model::ProductAttribute, **product_ids_lookup(ids) do |product_attribute|
+        assign_relation product_attribute, Mounter::Model::Product
+        product_attribute
+      end
+    end
+
+    def product_ids_lookup(ids)
+      ids ? { where: "product_id:#{ids}" } : {}
+    end
+
+    def shop
+      process Mounter::Model::Currency
+      process Mounter::Model::Language
+      process Mounter::Model::Shop, "shop" do |shop|
+        assign_relation shop, Mounter::Model::Currency
+        assign_relation shop, Mounter::Model::Language
+        shop
+      end
+    end
+
+    def settings_data
+      data = get_response "api/v1/themes/#{Editor.handle}/settings_data", page: 1 rescue return
+
+      if data.body.presence
+        data = JSON.parse(data.body)
+        File.write('config/settings_data.json', JSON.pretty_generate(data))
+      end
+    end
+
+    def customers(ids)
+      lookup = {}
+      lookup = {where: "id:#{ids}"} if ids.present?
+      process Mounter::Model::Customer, **lookup
+    end
+
+    def customer_groups
+      process Mounter::Model::CustomerGroup
+      #process Mounter::Model::CustomerCustomerGroup
+    end
+
+    def reviews
+      process Mounter::Model::Review do |review|
+        assign_relation review, Mounter::Model::Product
+        assign_relation review, Mounter::Model::Customer
+        review
+      end
+    end
+
+    def discounts
+      process Mounter::Model::Discount
+    end
+
+    def custom_fields
+      process Mounter::Model::CustomField
+    end
+
+    def subcriptions
+      process Mounter::Model::CustomerSubscriptionPlan
+      process Mounter::Model::CustomerSubscription
+    end
+
+    def process klass, path=klass.to_s.demodulize.tableize, **opts, &block
+      result = fetch("api/v1/#{path}", **opts).map(&(block || ->(this){this})).compact
+      uniq = result.uniq { |h| h[klass.primary_key.to_s] }
+      Logger.info "Received #{result.count} #{path.pluralize(result.count)}, kept #{uniq.count}.\n" if Editor["verbose"]
+      klass.assign uniq.map(&:to_hash)
+    end
+
+    def counter
+      ->(from, to, total) { "(#{from} to #{to} of #{total})" }
+    end
+
+    private
+
+    def fetch path, message="Syncing #{path}", **opts
+      records, response, page = [], nil, nil
+      Logger.notify message do
+        begin
+          Logger.info "#{message} #{page.message(&counter)}\r" if page
+          response = get_response(path, **opts.merge(page: page))
+          records += Array.wrap(response.parsed)
+        end while (page = Pagination.new(response).presence)
+      end
+      records
+    end
+
+    def get_response path, **opts
+      page = opts[:page]
+      page = page.try(:next_page)
+      opts[:page] = page
+      Api.request path, method: :get, &as_json(**opts)
+    end
+
+    def as_json(params={})
+      ->(req) {
+        req.headers["Accept"] = "application/json"
+        req.headers['Current-Shop'] = Editor["oauth-site"]
+        req.options.timeout = 120
+        req.params = params
+      }
+    end
+
+    def assign_relation attributes, klass
+      name = klass.to_s.demodulize.underscore
+      id = attributes["#{name}_id"]
+      primary_key = klass.primary_key
+      # attributes["#{name}_#{primary_key}"] = klass.where(id: id).first.try(primary_key) if id
+
+      # apparently where(id: id) still queries not by ID, but by primary key, so:
+      attributes["#{name}_#{primary_key}"] = klass.all.detect { |record| record[:id] == id }.try(primary_key)
+      attributes["#{name}_#{primary_key}"] ||= (attributes["#{name}_id"] = id if id)
+    end
+
+  end
+end end end

data/lib/shoperb_theme_editor/translations.rb

@@ -0,0 +1,22 @@
+module Shoperb module Theme module Editor
+  module Translations
+    extend self
+    mattr_accessor :locale
+
+    def translate(string, locale: self.locale, **args)
+      key = string.parameterize(separator: ".")
+      (translations[locale.to_s] || HashWithIndifferentAccess.new).fetch(key) { key }
+    end
+
+    alias :t :translate
+
+    def translations
+      Dir[File.join("translations", "*.json")].map do |file|
+        JSON.parse(File.read(file).force_encoding('UTF-8').presence || "{}", object_class: HashWithIndifferentAccess)
+      end.inject({}) do |hash, trans|
+        hash.merge!(trans)
+        hash
+      end
+    end
+  end
+end end end

data/lib/shoperb_theme_editor/utils.rb

@@ -0,0 +1,50 @@
+module Shoperb module Theme module Editor
+  module Utils
+    extend self
+
+    mattr_accessor :path
+    self.path = Pathname.new("")
+
+    def rel_path path
+      path = Pathname.new(path) unless path.is_a?(Pathname)
+      path.relative_path_from(calc_base(path))
+    end
+
+    def calc_base path
+      path.absolute? ? base : Pathname.new("./")
+    end
+
+    def base
+      Pathname.new(Pathname.new(""))
+    end
+
+    def write_file target
+      File.open(target, "w+b") { |f| f.write(yield) }
+    end
+
+    def mk_tempfile content, *names
+      Tempfile.new(names).tap do |file|
+        file.write(content)
+        file.flush
+        file.open
+      end
+    end
+
+    def rm_tempfile(file)
+      return unless file
+      if defined?(Tempfile) && file.is_a?(Tempfile)
+        begin
+          file.close unless file.closed?
+        rescue IOError
+        end
+        begin
+          file.unlink
+        rescue Errno::ENOENT, IOError
+        end
+      else
+        path = file.respond_to?(:to_path) ? file.to_path : file.to_s
+        File.delete(path) if path && !path.empty? && File.exist?(path)
+      end
+    end
+  end
+end end end

data/lib/shoperb_theme_editor.rb

@@ -0,0 +1,159 @@
+require "active_support/all"
+require "haml"
+require "rack"
+require "pry"
+require "shoperb_liquid"
+
+require_relative 'shoperb_theme_editor/ext'
+
+autoload :OpenStruct,         "ostruct"
+autoload :FileUtils,          "fileutils"
+autoload :Zip,                "zip"
+autoload :Pathname,           "pathname"
+autoload :Tempfile,           "tempfile"
+autoload :Time,               "time"
+autoload :OAuth2,             "oauth2"
+autoload :Faraday,            "faraday"
+autoload :Launchy,            "launchy"
+autoload :I18n,               "i18n"
+autoload :CoffeeScript,       "coffee_script"
+autoload :Sass,               "sass"
+autoload :ActionView,         "action_view"
+autoload :WEBrick,            "webrick"
+autoload :ActionDispatch,     "action_dispatch"
+autoload :Sinatra,            "sinatra"
+autoload :YAML,               "yaml"
+autoload :JSON,               "json"
+autoload :Logger,             "logger"
+autoload :URI,                "uri"
+autoload :Mime,               "action_dispatch/http/mime_type"
+autoload :Slop,               "slop"
+autoload :Sequel,             "sequel"
+require 'faraday/multipart'
+require_relative 'shoperb_theme_editor/ext/sequel.rb'
+
+module Shoperb module Theme
+  module Editor
+    extend self
+    mattr_accessor :config
+    delegate :[], :[]=, :reset, to: :config
+
+    def with_configuration(options, *args)
+      self.config = Configuration.new(options.to_hash.select { |_, value| !value.nil? }, *args)
+      `mkdir -p #{Utils.base + "data"}`
+      Sequel::Model.db = Sequel.sqlite((Utils.base + "data/data.db").to_s, setup_regexp_function: true)
+      begin
+        yield
+      rescue Interrupt => e
+        exit(130)
+      rescue Exception => e
+        Error.report(e)
+      ensure
+        self.config.save
+      end
+    end
+
+    def autoload_all mod, folder
+      Gem.find_files(
+        Pathname.new("shoperb_theme_editor/#{folder}/*.rb").cleanpath.to_s
+      ).each { |path|
+        name = Pathname.new(path).basename(".rb")
+        mod.autoload :"#{name.to_s.sub(/.*\./, '').camelize}",
+          Pathname.new("shoperb_theme_editor/#{folder}/#{name}").cleanpath.to_s
+      }
+    end
+
+    autoload_all self, "/"
+
+    def handle content=local_spec_content
+      spec(content)["handle"]
+    end
+
+    def spec content=local_spec_content
+      JSON.parse(content)
+    end
+
+    def settings_data
+      unless File.exist?('config/settings_data.json')
+        if File.exist?('presets/default.json')
+          File.open('config/settings_data.json', 'w') do |f|
+            settings = JSON.parse(File.read('presets/default.json'))['settings']
+            f.write JSON.pretty_generate({ general: settings })
+          end
+        end
+      end
+
+      if File.exist?('config/settings_data.json')
+        JSON.parse(File.read('config/settings_data.json'))
+      end
+    end
+
+    def local_spec_content
+      @local_spec_content ||= begin
+        if File.exist?(path = Utils.base + "config/spec.json")
+          File.read(path)
+        else
+          new_spec_content
+        end
+      end
+    end
+
+    # if spec is missing (for old themes)
+    def new_spec_content
+      content = JSON.parse(File.read(path = Utils.base + '.shoperb'))
+      spec_content = {
+        handle: content['handle'],
+        compile: {
+          stylesheets: ['application.css'],
+          javascripts: ['application.js']
+        }
+      }.to_json
+      Dir.mkdir 'config' unless File.exist?('config')
+      File.open('config/spec.json', 'w') {|f| f.write(spec_content) }
+      spec_content
+    end
+
+    # general theme settings (styles)
+    def theme_settings
+      (settings_data ? settings_data['general'].presence : nil) || {}
+    end
+
+    def presets
+      res = []
+
+      Pathname.glob(Utils.base + "presets/*.json") do |path|
+        content = File.read(path)
+        data = JSON.parse(content) rescue { "settings" => { } }
+
+        res.push([nil, data["settings"]]) if data["default"]
+        res.push([data["name_key"], data["settings"]])
+      end
+
+      res.to_h
+    end
+
+    def compiler asset_url, digests: true, **options
+      Artisans::ThemeCompiler.new(
+        File.expand_path(Utils.base),
+        asset_url,
+        settings: theme_settings,
+        compile: spec["compile"],
+        file_reader: SprocketsFileReader.new(digests: digests)
+      )
+    end
+
+    class SprocketsFileReader
+      def initialize(digests: true)
+        @digests = digests
+      end
+
+      def read(file)
+        File.read(file) if File.file?(file)
+      end
+
+      def find_digest(path)
+        @digests && File.exist?(path) ? Digest::MD5.hexdigest(File.read(path)) : ''
+      end
+    end
+  end
+end end