haravan_theme 0.0.25

data/lib/haravan_theme/api_checker.rb

@@ -0,0 +1,41 @@
+module HaravanTheme
+  class APIChecker
+    class APIResult
+      OK = 200
+      UNAUTHORIZED = 401
+      SERVER_ERROR_CODES = (500..599)
+      
+      attr_reader :response
+      def initialize(http_response)
+        @response = http_response
+      end
+
+      def accessed_api?
+        response.code == OK
+      end
+
+      def cannot_access_api?
+        !accessed_api?
+      end
+
+      def invalid_config?
+        response.code == UNAUTHORIZED
+      end
+
+      def api_down?
+        SERVER_ERROR_CODES.include?(response.code)
+      end
+    end
+
+    def initialize(client)
+      @client = client
+    end
+
+    def test_connectivity
+      return APIResult.new(client.get_index)
+    end
+
+    private
+    attr_reader :client
+  end
+end

data/lib/haravan_theme/cli.rb

@@ -0,0 +1,344 @@
+require 'thor'
+require 'yaml'
+YAML::ENGINE.yamler = 'syck' if defined? Syck
+require 'abbrev'
+require 'base64'
+require 'fileutils'
+require 'json'
+require 'filewatcher'
+require 'launchy'
+require 'mimemagic'
+require 'haravan_theme/file_filters'
+
+module HaravanTheme
+  EXTENSIONS = [
+    {mimetype: 'application/x-liquid', extensions: %w(liquid), parents: 'text/plain'},
+    {mimetype: 'application/json', extensions: %w(json), parents: 'text/plain'},
+    {mimetype: 'application/js', extensions: %w(map), parents: 'text/plain'},
+    {mimetype: 'application/vnd.ms-fontobject', extensions: %w(eot)},
+    {mimetype: 'image/svg+xml', extensions: %w(svg svgz)}
+  ]
+
+  def self.configureMimeMagic
+    HaravanTheme::EXTENSIONS.each do |extension|
+      MimeMagic.add(extension.delete(:mimetype), extension)
+    end
+  end
+
+  class Cli < Thor
+    include Thor::Actions
+
+    IGNORE = %w(config.yml)
+    DEFAULT_WHITELIST = %w(layout/ assets/ config/ snippets/ templates/ locales/)
+    TIMEFORMAT = "%H:%M:%S"
+
+    tasks.keys.abbrev.each do |shortcut, command|
+      map shortcut => command.to_sym
+    end
+
+    desc "check", "check configuration"
+    def check(exit_on_failure=false)
+      result = APIChecker.new(HaravanTheme).test_connectivity
+
+      if result.api_down?
+        say("Cannot connect to Haravan. API appears to be down", :red)
+        say("Visit http://status.haravan.com for more details", :yello)
+      elsif result.invalid_config?
+        say("Cannot connect to Haravan. Configuration is invalid.", :red)
+        say("Verify that your API key, password and domain are correct.", :yellow)
+        say("Visit https://github.com/haravan/haravan_theme#configuration for more details", :yellow)
+        say("If your shop domain is correct, the following URL should take you to the Private Apps page for the shop:", :yellow)
+        say("  https://#{config[:store]}/admin/apps/private", :yellow)
+      else
+        say("Haravan API is accessible and configuration is valid", :green) unless exit_on_failure
+      end
+
+      exit(1) if result.cannot_access_api? && exit_on_failure
+    end
+
+    desc "configure API_KEY PASSWORD STORE THEME_ID", "generate a config file for the store to connect to"
+    def configure(api_key=nil, password=nil, store=nil, theme_id=nil)
+      config = {:api_key => api_key, :password => password, :store => store, :theme_id => theme_id, :whitelist_files => Filters::Whitelist::DEFAULT_WHITELIST}
+      create_file('config.yml', config.to_yaml)
+      check(true)
+    end
+
+    desc "configure_oauth ACCESS_TOKEN STORE THEME_ID", "generate a config file for the store to connect to using an OAuth access token"
+    def configure_oauth(access_token=nil, store=nil, theme_id=nil)
+      config = {:access_token => access_token, :store => store, :theme_id => theme_id}
+      create_file('config.yml', config.to_yaml)
+    end
+
+    desc "bootstrap API_KEY PASSWORD STORE THEME_NAME", "bootstrap with Timber to shop and configure local directory."
+    method_option :master, :type => :boolean, :default => false
+    method_option :version, :type => :string, :default => "latest"
+    def bootstrap(api_key=nil, password=nil, store=nil, theme_name=nil)
+      HaravanTheme.config = {:api_key => api_key, :password => password, :store => store, :whitelist_files => Filters::Whitelist::DEFAULT_WHITELIST}
+      check(true)
+
+      theme_name ||= 'Timber'
+      say("Registering #{theme_name} theme on #{store}", :green)
+      theme = HaravanTheme.upload_timber(theme_name, options[:version])
+
+      say("Creating directory named #{theme_name}", :green)
+      empty_directory(theme_name)
+
+      say("Saving configuration to #{theme_name}", :green)
+      HaravanTheme.config.merge!(theme_id: theme['id'])
+      create_file("#{theme_name}/config.yml", HaravanTheme.config.to_yaml)
+
+      say("Downloading #{theme_name} assets from Haravan")
+      Dir.chdir(theme_name)
+      download()
+    rescue Releases::VersionError => e
+      say(e.message, :red)
+    end
+
+    desc "download FILE", "download the shops current theme assets"
+    method_option :quiet, :type => :boolean, :default => false
+    method_option :exclude
+    def download(*keys)
+      check(true)
+
+      puts("download FILE", "download the shops current theme assets")
+      puts("keys: ", keys)
+
+      assets = assets_for(keys, HaravanTheme.asset_list)
+
+      if options['exclude']
+        assets = assets.delete_if { |asset| asset =~ Regexp.new(options['exclude']) }
+      end
+
+      assets.each do |asset|
+        download_asset(asset)
+        say("#{HaravanTheme.api_usage} Downloaded: #{asset}", :green) unless options['quiet']
+      end
+      say("Done.", :green) unless options['quiet']
+    end
+
+    desc "open", "open the store in your browser"
+    def open(*keys)
+      if Launchy.open shop_theme_url
+        say("Done.", :green)
+      end
+    end
+
+    desc "upload FILE", "upload all theme assets to shop"
+    method_option :quiet, :type => :boolean, :default => false
+    def upload(*keys)
+      check(true)
+      assets = assets_for(keys, local_assets_list)
+      assets = keys.empty? ? local_assets_list : keys
+      assets.each do |asset|
+        send_asset(asset, options['quiet'])
+      end
+      say("Done.", :green) unless options['quiet']
+    end
+
+    desc "replace FILE", "completely replace shop theme assets with local theme assets"
+    method_option :quiet, :type => :boolean, :default => false
+    def replace(*keys)
+      check(true)
+      say("Are you sure you want to completely replace your shop theme assets? This is not undoable.", :yellow)
+      if ask("Continue? (Y/N): ") == "Y"
+        # only delete files on remote that are not present locally
+        # files present on remote and present locally get overridden anyway
+        remote_assets = keys.empty? ? (HaravanTheme.asset_list - local_assets_list) : keys
+        remote_assets.each do |asset|
+          delete_asset(asset, options['quiet']) unless HaravanTheme.ignore_files.any? { |regex| regex =~ asset }
+        end
+        local_assets = keys.empty? ? local_assets_list : keys
+        local_assets.each do |asset|
+          send_asset(asset, options['quiet'])
+        end
+        say("Done.", :green) unless options['quiet']
+      end
+    end
+
+    desc "remove FILE", "remove theme asset"
+    method_option :quiet, :type => :boolean, :default => false
+    def remove(*keys)
+      check(true)
+      keys.each do |key|
+        delete_asset(key, options['quiet'])
+      end
+      say("Done.", :green) unless options['quiet']
+    end
+
+    desc "watch", "upload and delete individual theme assets as they change, use the --keep_files flag to disable remote file deletion"
+    method_option :quiet, :type => :boolean, :default => false
+    method_option :keep_files, :type => :boolean, :default => false
+    def watch
+      check(true)
+      puts "Watching current folder: #{Dir.pwd}"
+      watcher do |filename, event|
+        filename = filename.gsub("#{Dir.pwd}/", '')
+        
+        next unless local_assets_list.include?(filename)
+        
+        action = if [:changed, :new].include?(event)
+          :send_asset
+        elsif event == :delete && !options['keep_files']
+          :delete_asset
+        else
+          raise NotImplementedError, "Unknown event -- #{event} -- #{filename}"
+        end
+
+        send(action, filename, options['quiet'])
+      end
+    end
+
+    desc "systeminfo", "print out system information and actively loaded libraries for aiding in submitting bug reports"
+    def systeminfo
+      ruby_version = "#{RUBY_VERSION}"
+      ruby_version += "-p#{RUBY_PATCHLEVEL}" if RUBY_PATCHLEVEL
+      puts "Ruby: v#{ruby_version}"
+      puts "Operating System: #{RUBY_PLATFORM}"
+      %w(Thor Listen HTTParty Launchy).each do |lib|
+        require "#{lib.downcase}/version"
+        puts "#{lib}: v" +  Kernel.const_get("#{lib}::VERSION")
+      end
+    end
+
+    no_commands do
+      def local_assets_list
+        FileFilters.new(
+          Filters::Whitelist.new(HaravanTheme.whitelist_files),
+          Filters::Blacklist.new(HaravanTheme.ignore_files)
+        ).select(local_files)
+      end
+    end
+
+    protected
+
+    def config
+      @config ||= YAML.load_file 'config.yml'
+    end
+
+    def shop_theme_url
+      url = config[:store]
+      url += "?preview_theme_id=#{config[:theme_id]}" if config[:theme_id] && config[:theme_id].to_i > 0
+      url
+    end
+
+    private
+    def assets_for(keys=[], files=[])
+      filter = FileFilters.new(Filters::CommandInput.new(keys))
+      filter.select(files)
+    end
+
+    def watcher
+      FileWatcher.new(Dir.pwd).watch() do |filename, event|
+        yield(filename, event)
+      end
+    end
+
+    def local_files
+      Dir.glob(File.join('**', '*')).reject do |f|
+        File.directory?(f)
+      end
+    end
+
+    def download_asset(key)
+      return unless valid?(key)
+      notify_and_sleep("Approaching limit of API permits. Naptime until more permits become available!") if HaravanTheme.needs_sleep?
+      asset = HaravanTheme.get_asset(key)
+      if asset['value']
+        # For CRLF line endings
+        content = asset['value'].gsub("\r", "")
+        format = "w"
+      elsif asset['attachment']
+        content = Base64.decode64(asset['attachment'])
+        format = "w+b"
+      end
+
+      FileUtils.mkdir_p(File.dirname(key))
+      File.open(key, format) {|f| f.write content} if content
+    end
+
+    def send_asset(asset, quiet=false)
+      return unless valid?(asset)
+      data = {:key => asset}
+      content = File.read(asset)
+      if binary_file?(asset) || HaravanTheme.is_binary_data?(content)
+        content = File.open(asset, "rb") { |io| io.read }
+        data.merge!(:attachment => Base64.encode64(content))
+      else
+        data.merge!(:value => content)
+      end
+
+      response = show_during("[#{timestamp}] Uploading: #{asset}", quiet) do
+        HaravanTheme.send_asset(data)
+      end
+      if response.success?
+        say("[#{timestamp}] Uploaded: #{asset}", :green) unless quiet
+      else
+        report_error(Time.now, "Could not upload #{asset}", response)
+      end
+    end
+
+    def delete_asset(key, quiet=false)
+      return unless valid?(key)
+      response = show_during("[#{timestamp}] Removing: #{key}", quiet) do
+        HaravanTheme.delete_asset(key)
+      end
+      if response.success?
+        say("[#{timestamp}] Removed: #{key}", :green) unless quiet
+      else
+        report_error(Time.now, "Could not remove #{key}", response)
+      end
+    end
+
+    def notify_and_sleep(message)
+      say(message, :red)
+      HaravanTheme.sleep
+    end
+
+    def valid?(key)
+      return true if DEFAULT_WHITELIST.include?(key.split('/').first + "/")
+      say("'#{key}' is not in a valid file for theme uploads", :yellow)
+      say("Files need to be in one of the following subdirectories: #{DEFAULT_WHITELIST.join(' ')}", :yellow)
+      false
+    end
+
+    def binary_file?(path)
+      mime = MimeMagic.by_path(path)
+      say("'#{path}' is an unknown file-type, uploading asset as binary", :yellow) if mime.nil? && ENV['TEST'] != 'true'
+      mime.nil? || !mime.text?
+    end
+
+    def report_error(time, message, response)
+      say("[#{timestamp(time)}] Error: #{message}", :red)
+      say("Error Details: #{errors_from_response(response)}", :yellow)
+    end
+
+    def errors_from_response(response)
+      object = {status: response.headers['status'], request_id: response.headers['x-request-id']}
+
+      errors = response.parsed_response ? response.parsed_response["errors"] : response.body
+
+      object[:errors] = case errors
+                        when NilClass
+                          ''
+                        when String
+                          errors.strip
+                        else
+                          errors.values.join(", ")
+                        end
+      object.delete(:errors) if object[:errors].length <= 0
+      object
+    end
+
+    def show_during(message = '', quiet = false, &block)
+      print(message) unless quiet
+      result = yield
+      print("\r#{' ' * message.length}\r") unless quiet
+      result
+    end
+
+    def timestamp(time = Time.now)
+      time.strftime(TIMEFORMAT)
+    end
+  end
+end
+HaravanTheme.configureMimeMagic

data/lib/haravan_theme/file_filters.rb

@@ -0,0 +1,18 @@
+require 'haravan_theme/filters/blacklist'
+require 'haravan_theme/filters/whitelist'
+require 'haravan_theme/filters/command_input'
+
+module HaravanTheme
+  class FileFilters
+    def initialize(*filters)
+      raise ArgumentError, "Must have at least one filter to apply" unless filters.length > 0
+      @filters = filters
+    end
+
+    def select(list)
+      @filters.reduce(list) do |results, filter|
+        filter.select(results)
+      end
+    end
+  end
+end

data/lib/haravan_theme/filters/blacklist.rb

@@ -0,0 +1,17 @@
+module HaravanTheme
+  module Filters
+    class Blacklist
+      attr_reader :patterns
+
+      def initialize(pattern_strings=[])
+        @patterns = pattern_strings.map { |p| Regexp.new(p)}
+      end
+
+      def select(list)
+        list.select do |entry|
+          patterns.none? { |pat| pat.match(entry) }
+        end
+      end
+    end
+  end
+end

data/lib/haravan_theme/filters/command_input.rb

@@ -0,0 +1,17 @@
+module HaravanTheme
+  module Filters
+    class CommandInput
+      attr_reader :patterns
+      def initialize(inputs=[])
+        @patterns = inputs.map { |i| Regexp.compile(i) }
+      end
+
+      def select(list)
+        return list if patterns.empty?
+        list.select { |entry|
+          patterns.any? { |pat| pat.match(entry) }
+        }
+      end
+    end
+  end
+end

data/lib/haravan_theme/filters/whitelist.rb

@@ -0,0 +1,19 @@
+module HaravanTheme
+  module Filters
+    class Whitelist
+      DEFAULT_WHITELIST = %w(layout/ assets/ config/ snippets/ templates/ locales/)
+
+      attr_reader :patterns
+
+      def initialize(pattern_strings=[])
+        @patterns = (pattern_strings.empty? ? DEFAULT_WHITELIST : pattern_strings).map { |pattern| Regexp.new(pattern) }
+      end
+
+      def select(list)
+        list.select do |entry|
+          patterns.any? { |pat| pat.match(entry) }
+        end
+      end
+    end
+  end
+end

data/lib/haravan_theme/releases.rb

@@ -0,0 +1,57 @@
+require 'httparty'
+require 'rss'
+
+module HaravanTheme
+  FEED_URL = 'https://github.com/Haravan/Timber/releases.atom'
+  ZIP_URL  = 'https://github.com/Haravan/Timber/archive/%s.zip'
+
+  class Releases
+    class VersionError < StandardError; end
+    Release = Struct.new(:version) do
+      def zip_url
+        ZIP_URL % version
+      end
+    end
+
+    def fetch!
+      response = HTTParty.get(FEED_URL)
+      raise "Could not retrieve feed from #{FEED_URL}" if response.code != 200
+      @feed = RSS::Parser.parse(response.body)
+    end
+
+    def all
+      @all ||= begin
+        versioned_releases.reduce({'master' => master, 'latest' => latest}) do |all, release|
+          all[release.version] = release
+          all
+        end
+      end
+    end
+
+    def find(version)
+      release = all[version]
+      if release.nil?
+        error = [
+          "Invalid version '#{version}'.",
+          "Valid versions are:",
+        ].concat(all.keys.map{|v| "  #{v}"})
+        raise VersionError, error.join("\n")
+      end
+      release
+    end
+
+    private
+    def versioned_releases
+      fetch! unless @feed
+      @versioned_releases ||= @feed.items.map { |item| Release.new(item.title.content) }
+    end
+
+    def latest
+      Release.new(versioned_releases.first.version)
+    end
+
+    def master
+      Release.new('master')
+    end
+  end
+end

data/lib/haravan_theme/version.rb

@@ -0,0 +1,3 @@
+module HaravanTheme
+  VERSION = "0.0.25"
+end

data/lib/haravan_theme.rb

@@ -0,0 +1,171 @@
+require 'httparty'
+require 'base64'
+module HaravanTheme
+  REMOTE_CERT_FILE = 'http://curl.haxx.se/ca/cacert.pem'
+  CA_CERT_FILE = File.expand_path(File.dirname(__FILE__) + '/certs/cacert.pem')
+  include HTTParty
+  ssl_ca_file CA_CERT_FILE
+  @@current_api_call_count = 0
+  @@total_api_calls = 40
+
+  NOOPParser = Proc.new {|data, format| {} }
+  TIMER_RESET = 10
+  PERMIT_LOWER_LIMIT = 3
+  MAX_TIMBER_RETRY = 5
+
+
+  def self.test?
+    ENV['test']
+  end
+
+  def self.manage_timer(response)
+    return unless response.headers['x-haravan-shop-api-call-limit']
+    @@current_api_call_count, @@total_api_calls = response.headers['x-haravan-shop-api-call-limit'].split('/')
+    @@current_timer = Time.now if @current_timer.nil?
+  end
+
+  def self.critical_permits?
+    @@total_api_calls.to_i - @@current_api_call_count.to_i < PERMIT_LOWER_LIMIT
+  end
+
+  def self.passed_api_refresh?
+    delta_seconds > TIMER_RESET
+  end
+
+  def self.delta_seconds
+    Time.now.to_i - @@current_timer.to_i
+  end
+
+  def self.needs_sleep?
+    critical_permits? && !passed_api_refresh?
+  end
+
+  def self.sleep
+    if needs_sleep?
+      Kernel.sleep(TIMER_RESET - delta_seconds)
+      @current_timer = nil
+    end
+  end
+
+  def self.api_usage
+    "[API Limit: #{@@current_api_call_count || "??"}/#{@@total_api_calls || "??"}]"
+  end
+
+
+  def self.asset_list
+    # HTTParty parser chokes on assest listing, have it noop
+    # and then use a rel JSON parser.
+    response = haravan.get(path, :parser => NOOPParser)
+    manage_timer(response)
+
+    assets = JSON.parse(response.body)["assets"].collect {|a| a['key'] }
+    # Remove any .css files if a .css.liquid file exists
+    assets.reject{|a| assets.include?("#{a}.liquid") }
+  end
+
+  def self.get_asset(asset)
+    response = haravan.get(path, :query =>{:asset => {:key => asset}}, :parser => NOOPParser)
+    manage_timer(response)
+
+    # HTTParty json parsing is broken?
+    asset = response.code == 200 ? JSON.parse(response.body)["asset"] : {}
+    asset['response'] = response
+    asset
+  end
+
+  def self.send_asset(data)
+    response = haravan.put(path, :body => JSON.generate({:asset => data} ))
+    manage_timer(response)
+    response
+  end
+
+  def self.delete_asset(asset)
+    response = haravan.delete(path, :body =>{:asset => {:key => asset}})
+    manage_timer(response)
+    response
+  end
+
+  def self.upload_timber(name, version, retries=0)
+    release = Releases.new.find(version)
+    response = haravan.post("/admin/themes.json", :body => {:theme => {:name => name, :src => release.zip_url, :role => 'unpublished'}})
+    manage_timer(response)
+    body = JSON.parse(response.body)
+    if theme = body['theme']
+      puts "Successfully created #{name} using Haravan Timber #{version}"
+      watch_until_processing_complete(theme)
+    elsif retries < MAX_TIMBER_RETRY
+      upload_timber(name, version, retries + 1)
+    else
+      puts "Could not download theme!"
+      puts body
+      exit 1
+    end
+  end
+
+  def self.config
+    @config ||= if File.exist? 'config.yml'
+      config = YAML.load(File.read('config.yml'))
+      config
+    else
+      puts "config.yml does not exist!" unless test?
+      {}
+    end
+  end
+
+  def self.config=(config)
+    @config = config
+  end
+
+  def self.path
+    @path ||= config[:theme_id] ? "/admin/themes/#{config[:theme_id]}/assets.json" : "/admin/assets.json"
+  end
+
+  def self.ignore_files
+    (config[:ignore_files] || []).compact
+  end
+
+  def self.whitelist_files
+    (config[:whitelist_files] || []).compact
+  end
+
+  def self.is_binary_data?(string)
+    if string.respond_to?(:encoding)
+      string.encoding == "US-ASCII"
+    else
+      ( string.count( "^ -~", "^\r\n" ).fdiv(string.size) > 0.3 || string.index( "\x00" ) ) unless string.empty?
+    end
+  end
+
+  def self.check_config
+    haravan.get(path).code == 200
+  end
+
+  def self.get_index
+    puts(config[:theme_id] ? '' : "Hãy nhập theme_id")
+    haravan.get(path)
+  end
+
+  private
+  def self.haravan
+    basicAuth = Base64.strict_encode64(config[:api_key] + ':' + config[:password])
+    headers 'accept' => '*/*'
+    headers 'Content-Type' => 'application/json'
+    headers 'Authorization' => 'Basic ' + basicAuth
+    base_uri "https://#{config[:store]}"
+
+    puts(base_uri)
+
+    HaravanTheme
+  end
+
+  def self.watch_until_processing_complete(theme)
+    count = 0
+    while true do
+      Kernel.sleep(count)
+      response = haravan.get("/admin/themes/#{theme['id']}.json")
+      theme = JSON.parse(response.body)['theme']
+      return theme if theme['previewable']
+      count += 5
+    end
+  end
+end

data/shipit.rubygems.yml

@@ -0,0 +1 @@
+# using the default shipit config