ledger_sync 1.3.3 → 1.4.2

data/bin/quickbooks_online_oauth_server.rb

@@ -0,0 +1,102 @@
+# Setup
+#
+# gem install bundler
+# Ensure you have http://localhost:5678 (or PORT) as a Redirect URI in QBO.
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'dotenv'
+  gem 'ledger_sync'
+  gem 'rack'
+  gem 'pd_ruby'
+end
+
+puts 'Gems installed and loaded!'
+
+require 'pd_ruby'
+require 'socket'
+require 'dotenv'
+require 'rack'
+require 'ledger_sync'
+require 'rack/lobster'
+
+Dotenv.load
+
+port = ENV.fetch('PORT', 5678)
+app = Rack::Lobster.new
+server = TCPServer.new port
+
+base_url = "http://localhost:#{port}"
+
+puts "Listening at #{base_url}"
+
+client_id = ENV.fetch('QUICKBOOKS_ONLINE_CLIENT_ID')
+
+raise 'QUICKBOOKS_ONLINE_CLIENT_ID not set in ../.env' if client_id.blank?
+
+client = LedgerSync::Ledgers::QuickBooksOnline::Client.new_from_env(test: true)
+
+puts 'Go to the following URL:'
+puts client.authorization_url(redirect_uri: base_url)
+
+while session = server.accept
+  request = session.gets
+
+  puts request
+
+  # 1
+  method, full_path = request.split(' ')
+
+  # 2
+  path, query = full_path.split('?')
+
+  params = Hash[query.split('&').map { |e| e.split('=') }] if query.present?
+
+  client.set_credentials_from_oauth_code(
+    code: params.fetch('code'),
+    realm_id: params.fetch('realmId'),
+    redirect_uri: base_url
+  )
+
+  puts "\n"
+
+  puts 'access_token:'
+  puts client.access_token
+  puts "\n"
+  puts 'client_id:'
+  puts client.client_id
+  puts "\n"
+  puts 'client_secret:'
+  puts client.client_secret
+  puts "\n"
+  puts 'realm_id:'
+  puts client.realm_id
+  puts "\n"
+  puts 'refresh_token:'
+  puts client.refresh_token
+  puts "\n"
+
+  puts 'Done!'
+
+  status = 200
+  body = 'Done'
+  headers = {
+    'Content-Length' => body.size
+  }
+
+  session.print "HTTP/1.1 #{status}\r\n"
+
+  headers.each do |key, value|
+    session.print "#{key}: #{value}\r\n"
+  end
+
+  session.print "\r\n"
+
+  session.print body
+
+  session.close
+
+  break
+end

data/docs/.gitignore

@@ -0,0 +1,4 @@
+# Ignore everything in this directory
+*
+# Except this file
+!.gitignore

data/documentation/build.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+parent_path=$( cd "$(dirname "${BASH_SOURCE[0]}")" ; pwd -P )
+
+cd "$parent_path"
+cd ..
+bundle install
+cd documentation
+ruby generate.rb
+cd site
+bundle exec jekyll build -d ../../docs

data/documentation/generate.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# Setup
+#
+# gem install bundler
+# Ensure you have http://localhost:5678 (or PORT) as a Redirect URI in QBO.
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'simply_serializable'
+  gem 'ledger_sync', path: '../'
+  gem 'pd_ruby'
+  gem 'colorize'
+  gem 'byebug'
+end
+
+require 'ledger_sync'
+require 'pd_ruby'
+require 'erb'
+require 'fileutils'
+
+require_relative 'helper_methods'
+require_relative 'generators/generator'
+require_relative 'generators/guides/generator'
+require_relative 'generators/reference/generator'
+
+Docs::Guides::Generator.new.generate
+Docs::Reference::Generator.new.generate
+
+green 'All done!'

data/documentation/generators/generator.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative 'template'
+
+module Docs
+  class Generator
+    module Methods
+      def clear_dir(path, except: [])
+        dir_path = docs_path(path)
+        yellow "Clearing: #{dir_path}"
+        Dir.foreach(dir_path) do |f|
+          next if except.include?(f)
+
+          fn = File.join(dir_path, f)
+          next if f == '.'
+          next if f == '..'
+
+          rm(fn)
+        end
+        green "Cleared: #{dir_path}"
+        nl
+      end
+
+      def cp(src, dest, *args)
+        yellow "Copying #{src} to #{dest}"
+        FileUtils.cp_r(src, dest, *args)
+        green "Copied #{src} to #{dest}"
+        nl
+      end
+
+      def destination_path(*args, **keywords)
+        docs_path(*args, **{ format: :md }.merge(keywords))
+      end
+
+      def docs_path(*path, format: nil)
+        path = path.map(&:to_s)
+
+        File.join(
+          docs_root_path,
+          *path[0..-2],
+          [path.last, format].flatten.compact.join('.')
+        )
+      end
+
+      def docs_root_path
+        @docs_root_path ||= ENV.fetch('DOCS_ROOT_PATH', File.join(__dir__, '../site'))
+      end
+
+      def ledgers
+        LedgerSync.ledgers
+                  .to_a
+                  .map(&:last)
+                  .uniq
+                  .to_a
+                  .sort_by(&:root_key)
+      end
+
+      def rm(fn)
+        yellow "Removing: #{fn}"
+        FileUtils.rm_rf(fn, secure: true)
+        green "Removed: #{fn}"
+        nl
+      end
+
+      def template_path(*path, format: :md)
+        path = path.map(&:to_s)
+
+        File.join(
+          docs_root_path,
+          '_templates',
+          *path[0..-2],
+          "#{path.last}.#{format}.erb"
+        )
+      end
+    end
+
+    include Methods
+    extend Methods
+  end
+end

data/documentation/generators/guides/generator.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Docs
+  module Guides
+    class Generator < Docs::Generator
+      def generate
+        clear_dir(
+          self.class.destination_folder,
+          except: [
+            'index.md'
+          ]
+        )
+
+        ledgers.each_with_index do |ledger, i|
+          Docs::Template.new(
+            data: {
+              ledger: ledger,
+              weight: i + 1
+            },
+            destination_path: destination_path(
+              self.class.destination_folder,
+              ledger.root_key
+            ),
+            template_path: template_path(:guides, :ledger)
+          ).write
+
+          nl
+        end
+      end
+
+      def self.destination_folder
+        'guides/ledgers'
+      end
+    end
+  end
+end

data/documentation/generators/reference/generator.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative 'ledger/generator'
+
+module Docs
+  module Reference
+    class Generator < Docs::Generator
+      def generate
+        ledgers.each do |ledger|
+          Ledger::Generator.new(ledger: ledger).generate
+        end
+
+        generate_indexes
+        generate_layouts
+        update_nav
+      end
+
+      private
+
+      def generate_indexes
+        ledgers.each do |client|
+          Docs::Template.new(
+            data: {
+              client: client.client_class
+            },
+            destination_path: docs_path(:reference, client.root_key, :resources, 'index.md'),
+            template_path: template_path(
+              :reference,
+              :resources,
+              :index
+            )
+          ).write
+        end
+      end
+
+      def generate_layouts
+        ledgers.each do |ledger|
+          Docs::Template.new(
+            data: {
+              client: ledger
+            },
+            destination_path: docs_path(:_layouts, "reference_#{ledger.root_key}.html"),
+            template_path: template_path(
+              :_layouts,
+              :reference_ledger,
+              format: :html
+            )
+          ).write
+        end
+      end
+
+      def update_nav
+        config_path = docs_path('_config.yml')
+        config = YAML.load_file(config_path)
+        nav_links = config['header']['nav_links']
+        nav_links.map do |nav_link|
+          if nav_link['label'] == 'Reference'
+            nav_link['subnav_links'] = ledgers.map do |ledger|
+              {
+                'label' => ledger.name,
+                'url' => "reference/#{ledger.root_key}",
+                'type' => 'link'
+              }
+            end
+          else
+            nav_link
+          end
+        end
+
+        File.open(config_path, 'w') do |h|
+          h.write config.to_yaml
+        end
+      end
+    end
+  end
+end

data/documentation/generators/reference/ledger/generator.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Docs
+  module Reference
+    module Ledger
+      class Generator < Docs::Generator
+        attr_reader :ledger
+
+        def initialize(args = {})
+          @ledger = args.fetch(:ledger)
+        end
+
+        def client_class
+          @client_class ||= ledger.client_class
+        end
+
+        def generate
+          yellow "Generating Reference for #{key}"
+          remove_current_directory
+          copy_template_directory
+          generate_resource_files
+          green "Generated Reference for #{key}"
+        end
+
+        def key
+          @key ||= ledger.root_key
+        end
+
+        def resources
+          @resources ||= client_class.resources.to_a.sort
+        end
+
+        private
+
+        def copy_template_directory
+          cp(docs_path(:_includes, :reference, key), docs_path(:reference))
+        end
+
+        def remove_current_directory
+          rm(docs_path(:reference, key))
+        end
+
+        def generate_resource_files
+          FileUtils.mkdir(docs_path(:reference, key, :resources))
+
+          template_path = Generator.template_path(:reference, :resources, :resource)
+          count = 1
+          resources.each do |resource_key, resource|
+            destination_path = Generator.destination_path(
+              :reference,
+              ledger.root_key,
+              :resources,
+              resource_key
+            )
+
+            Docs::Template.new(
+              data: {
+                resource: resource,
+                client: client_class,
+                weight: count
+              },
+              destination_path: destination_path,
+              template_path: template_path
+            ).write
+
+            count += 1
+          end
+        end
+      end
+    end
+  end
+end

data/documentation/generators/template.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Docs
+  class Template
+    attr_reader :data,
+                :destination_path,
+                :template_path
+
+    def initialize(args = {})
+      @data = args.fetch(:data)
+      @destination_path = args.fetch(:destination_path)
+      @template_path = args.fetch(:template_path)
+    end
+
+    def write
+      template = ERB.new(File.read(template_path), trim_mode: '-')
+      yellow "Generating template: #{template_path}"
+      File.open(destination_path, 'w') { |f| f.write template.result_with_hash(data) }
+      green "Wrote to destination: #{destination_path}"
+    end
+  end
+end