atk_toolbox 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7be1f743af7afd55414c41e1a58373c22b922e891766d41a08027ca91c85662b
+  data.tar.gz: 9957d137a35201bb5f6b9302b4618f80a23af7535bdcd80f04729148be349674
+SHA512:
+  metadata.gz: c778630a2ffd8c94d494a6b913ae5b207e4d78624b0f56a8806cdd133526f8ecbf9229406232658d830b4b36f438594706185e1c1df7c22b068f48abb2701451
+  data.tar.gz: 933bb35bb46fb63e677aa2f1e600dc81a58b2bfd20acd6a54ac5e43f79195b475906863f8d8164e9283cd7807037766d80da6326060dd82d31bb495b149ad727

data/lib/atk/cmd.rb

@@ -0,0 +1,7 @@
+class String
+    # add a - operator to strings that makes it behave like a system() call 
+    # but it shows stderr 
+    def -@
+        return Process.wait(Process.spawn(self))
+    end
+end

data/lib/atk/download.rb

@@ -0,0 +1,39 @@
+def download(input_1=nil, from:nil, url:nil, as:nil)
+    require 'open-uri'
+    # argument checking 
+        # if only one argument, either input_1 or url
+        if ((input_1!=nil) != (url!=nil)) && (from==nil) && (as==nil)
+            # this covers:
+            #    download     'site.com/file'
+            the_url = url || input_1
+            file_name = the_url.match /(?<=\/)[^\/]+\z/ 
+            file_name = file_name[0]
+        elsif (as != nil) && ((input_1!=nil)!=(url!=nil))
+            # this covers:
+            #    download     'site.com/file' as:'file'
+            #    download url:'site.com/file' as:'file'
+            the_url = url || input_1
+            file_name = as
+        elsif ((from!=nil) != (url!=nil)) && input_1!=nil
+            # this covers:
+            #    download 'file' from:'site.com/file'
+            #    download 'file'  url:'site.com/file'
+            the_url = from || url
+            file_name = input_1
+        else
+            message_ = "I'm not sure how you're using the download function.\n"
+            message_ << "Please use one of the following methods:\n"
+            message_ << "    download     'site.com/file'\n"
+            message_ << "    download     'site.com/file', as:'file'\n"
+            message_ << "    download url:'site.com/file', as:'file'\n"
+            message_ << "    download 'file', from:'site.com/file'\n"
+            message_ << "    download 'file',  url:'site.com/file'\n"
+            raise message_
+        end#if
+    #end argument checking
+
+    # actually download the file
+    open(file_name, 'wb') do |file|
+        file << open(the_url).read
+    end
+end

data/lib/atk/os.rb

@@ -0,0 +1,72 @@
+# every OS version is a perfect heirarchy of versions and sub verisons that may or may not be chronological
+# every OS gets it's own custom heirarchy since there are issues like x86 support and "student edition" etc
+# the plan is to release this heirarchy on its own repo, and to get pull requests for anyone who wants to add their own OS
+os_heirarchy = {
+    "windows" => {
+        "10"    => {},
+        "8.1"   => {},
+        "8"     => {},
+        "7"     => {},
+        "vista" => {},
+        "xp"    => {},
+        "95"    => {},
+    },
+    "mac" => {
+        "mojave"         => {},
+        "high sierra"    => {},
+        "sierra"         => {},
+        "el capitan"     => {},
+        "yosemite"       => {},
+        "mavericks"      => {},
+        "mountain lion"  => {},
+        "lion"           => {},
+        "snow leopard"   => {},
+        "leopard"        => {},
+        "tiger"          => {},
+        "panther"        => {},
+        "jaguar"         => {},
+        "puma"           => {},
+        "cheetah"        => {},
+        "kodiak"         => {},
+    },
+    "ubuntu"     => {},
+    "arch"       => {},
+    "manjaro"    => {},
+    "deepin"     => {},
+    "centos"     => {},
+    "debian"     => {},
+    "fedora"     => {},
+    "elementary" => {},
+    "zorin"      => {},
+    "raspian"    => {},
+    "android"    => {},
+}
+
+# 
+# Groups
+# 
+# the groups are the pratical side of the OS, they describe the OS rather than fit it prefectly into a heirarchy
+module OS
+    # TODO: have the version pick one of the verions in the os_heirarchy according to the current OS
+    def self.version
+        raise "not yet implemented"
+    end
+    
+    def self.is?(adjective)
+        # summary:
+            # this is a function created for convenience, so it doesn't have to be perfect
+            # you can use it to ask about random qualities of the current OS and get a boolean response
+        # convert to string (if its a symbol)
+        adjective = adjective.to_s
+        case adjective
+            when 'windows'
+                return (/cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM) != nil
+            when 'mac'
+                return (/darwin/ =~ RUBY_PLATFORM) != nil
+            when 'linux'
+                return (not OS.is?(:windows)) && (not OS.is?(:mac))
+            when 'unix'
+                return OS.is?(:windows) || OS.is?(:mac)
+        end
+    end
+end

data/lib/atk/output.rb

@@ -0,0 +1,5 @@
+# Functions to be used for consistent output to the user
+
+module ATKIO
+
+end

data/lib/atk/package_managers.rb

@@ -0,0 +1,111 @@
+class PackageManager
+    def self.installed?(app_name, version=nil)
+        puts 'This has not been implemented yet'
+    end
+
+    def self.install(app_name, version=nil)
+        puts 'This has not been implemented yet'
+    end
+
+    def self.uninstall(app_name, version=nil)
+        puts 'This has not been implemented yet'
+    end
+
+    def self.update_app(app_name)
+        puts 'This has not been implemented yet'
+    end
+end
+
+class Scoop < PackageManager
+
+    @@scoop_dir = ENV['SCOOP'] or '#{Dir.home}/scoop'
+    @@scoop_global_dir = ENV['SCOOP_GLOBAL'] or '#{ENV["ProgramData"]}/scoop'
+
+    def self.base_dir(global=false)
+        return global ? @@scoop_global_dir : @@scoop_dir
+    end
+
+    def self.apps_dir(global=false)
+        root = base_dir(global)
+        return '#{root}/apps'
+    end 
+
+    def self.app_dir(app_name, global=false)
+        root = apps_dir(global)
+        return '#{root}/#{app_name}'
+    end
+
+    def self.add_bucket(bucket_name, bucket_location=nil)
+        if (bucket_location == nil) 
+            `scoop bucket add #{bucket_name}`
+        else
+            `scoop bucket add #{bucket_name} #{bucket_location}`
+        end
+    end
+
+    def self.switch_app_version(app_name, version=nil)
+        if(version == nil)
+            `scoop reset #{app_name}`
+        else
+            `scoop reset #{app_name}@#{version}`
+        end
+    end
+
+    # Overriden Methods
+
+    def self.installed?(app_name, version=nil) 
+        # if(global == nil) { return (installed?(app_name, true) or installed? (app_name, false)) }
+        # Dependencies of the format "bucket/dependency" install in a directory of form
+        # "dependency". So we need to extract the bucket from the name and only give the app
+        # name to is_directory
+        # TODO: add support for checking if version is installed
+        app_name = app_name.split("/")[-1]
+        return File.directory?(File.expand_path(app_dir(app_name)))
+    end
+
+    def self.install(app_name, version=nil) 
+        if(installed?(app_name))
+            puts 'You already have #{app_name} installed'
+            return
+        end
+
+        if(version == nil)
+            `scoop install #{app_name}`
+        else
+            `scoop install #{app_name}@#{version}`
+        end
+    end
+
+    def self.uninstall(app_name, version=nil)
+        if(app_name == 'scoop')
+            puts 'You are trying to uninstall scoop which is a dependency for ATK. We will not let you uninstall Scoop through ATK'
+            return
+        end
+
+        if(version == nil)
+            `scoop uninstall #{app_name}`
+        else
+            `scoop uninstall #{app_name}@#{version}`
+        end
+    end
+
+    def self.update_app(app_name)
+        `scoop update #{app_name}`
+    end
+end
+
+class Homebrew < PackageManager
+
+end
+
+class Apt < PackageManager
+
+end
+
+class Pacman < PackageManager
+
+end
+
+class Yum < PackageManager
+
+end

data/lib/atk/yaml_info_parser.rb

@@ -0,0 +1,248 @@
+#!/usr/bin/ruby
+require "yaml"
+require_relative './cmd'
+require_relative './os'
+
+# 
+# Create loaders for ruby code literal and console code literal
+# 
+    class Code
+        @@tags = {}
+        def self.tags
+            return @@tags
+        end
+        
+        def self.register_as(yaml_tag_name)
+            YAML.add_tag(yaml_tag_name, self.class)
+            Code.tags[yaml_tag_name] = self.class
+        end
+        
+        def init_with(coder)
+            @value = coder.scalar
+        end
+        
+        def run
+            # TODO: improve this error message
+            raise "This needs to be overloaded"
+        end
+        
+        def to_s
+            puts @value
+        end
+    end
+    
+    # 
+    # Ruby Code/Evaluation
+    # 
+    class RubyCode < Code
+        def run
+            eval(@value)
+        end
+    end
+    RubyCode.register_as('!language/ruby')
+    # add an evaluater for ruby code
+    ruby_evaluation_tag = 'evaluate/ruby'
+    Code.tags[ruby_evaluation_tag] = "evaluate"
+    YAML.add_domain_type("", ruby_evaluation_tag) do |type, value|
+        if value.is_a? String
+            eval(value)
+        else
+            value
+        end
+    end
+
+    # 
+    # Console Code
+    # 
+    # TODO: add support for console code
+    class ConsoleCode < Code
+        def run
+            -"#{@value}"
+        end
+    end
+    ConsoleCode.register_as('!language/console')
+# 
+# project info (specific to operating sytem)
+# 
+# setting/getting values via an object (instead of opening/closing a file)
+class Info
+    # main keys
+        # (using_atk_version)
+        # (project)
+        # (advanced_setup)
+    # any-level project detail keys:
+        # (dependencies)
+        # (project_commands)
+        # (structures)
+        # (local_package_managers)
+        # (put_new_dependencies_under)
+        # (environment_variables)
+    
+    # TODO: figure out a way of adding write access to the info.yaml
+    # TODO: if there is no (using_atk_version), then add one with the current version
+    # TODO:
+    #     if there is no (project) or no (advanced_setup), then assume its not an ATK setup 
+    #     (quit somehow depending on how this code was invoked)
+    # TODO:
+    #    if there are ()'s in a key inside of the (project)
+    #    but the key isn't part of the standard keys
+    #    then issue a warning, and give them a suggestion to the next-closest key
+    
+    @@data = nil
+    @@valid_variables = ['context', 'os']
+    @@valid_operators = ['is']
+    
+    # TODO: write tests for this function
+    def self.parse_when_statment(statement)
+        # remove the 'when' and paraentheses
+        expression = statement.sub( /when\((.*)\)/, "\\1" )
+        # create the pattern for finding variables
+        variable_pattern = /\A\s*--(?<variable>#{@@valid_variables.join('|')})\s+(?<operator>#{@@valid_operators.join('|')})\s+(?<value>.+)/
+        groups = expression.match(variable_pattern)
+        if groups == nil
+            raise "\n\nIn the info.yaml file\nI couldn't any of the variables in #{statement}\nMake sure the format is:\n    when( --VARIABLE *space* OPERATOR *space* VALUE )\nvalid variables are: #{valid_variables}\nvalid operators are: #{valid_operators}"
+        end
+        value = groups['value'].strip
+        
+        substitutions = ->(value) do
+            value.gsub!( /\\'/, "'" )
+            value.gsub!( /\\"/, '"' )
+            value.gsub!( /\\n/, "\n" )
+            value.gsub!( /\\t/, "\t" )
+        end
+        
+        # if it has single quotes
+        if value =~ /'.+'/
+            value.sub!( /'(.+)'/, "\\1" )
+            substitutions[value]
+        # if double quotes
+        elsif value =~ /".+"/
+            value.sub!( /"(.+)"/, "\\1" )
+            substitutions[value]
+        else
+            raise "\n\nIn the info.yaml file\nthe value: #{value} in the statment:\n#{statement}\n\nwas invalid. It probably needs single or double quotes around it"
+        end
+        
+        return {
+            variable: groups['variable'],
+            operator: groups['operator'],
+            value: value
+        }
+    end
+    
+    def self.evaluate_when_condition(data)
+        case data[:variable]
+        when 'context'
+            raise "\n\ncontext functionality has not been implemented yet"
+        when 'os'
+            case data[:operator]
+                when 'is'
+                    return OS.is?(data[:value])
+                else
+                    raise "unknown operator: #{data[:operator]}"
+            end
+        else
+            raise "\n\nunknown variable: #{data[:variable]}"
+        end
+    end
+    
+    # def self.parse_language_evaluations(value)
+    #     if value.is_a?(Evaluation)
+    #         return Info.parse_language_evaluations(value.run())
+    #     elsif value.is_a?(Hash)
+    #         new_hash = {}
+    #         for each_key, each_value in value
+    #             new_hash[each_key] = Info.parse_language_evaluations(each_value)
+    #         end
+    #         return new_hash
+    #     elsif value.is_a?(Array)
+    #         new_array = []
+    #         for each in value
+    #             new_array.push(Info.parse_language_evaluations(each))
+    #         end
+    #         return new_array
+    #     else
+    #         return value
+    #     end
+    # end
+    
+    def self.parse_advanced_setup(unchecked_hashmap, current_project_settings)
+        for each_key, each_value in unchecked_hashmap.clone()
+            case
+            # check for yaml-when statements
+            when each_key =~ /\Awhen\(.*\)\z/ && each_value.is_a?(Hash)
+                statement_data = Info.parse_when_statment(each_key)
+                # if the when condition was true
+                if Info.evaluate_when_condition(statement_data)
+                    # recursively parse the tree
+                    Info.parse_advanced_setup(each_value, current_project_settings)
+                end
+            # transfer all the normal keys to the current_project_settings
+            else
+                current_project_settings[each_key] = each_value
+            end
+        end
+    end
+    
+    def self.load_if_needed
+        # if the data hasn't been loaded then load it first
+        if @@data == nil
+            Info.load_from_yaml
+        end
+    end
+    
+    def self.load_from_yaml
+        # this function sets up:
+            # @@data
+            # @@project
+            # @@settings
+            # and also
+            # @@dependencies
+            # @@project_commands
+            # @@structures
+            # @@local_package_managers
+            # @@put_new_dependencies_under
+            # @@environment_variables
+        
+        # get the local yaml file
+        # TODO: have this search the parent dir's to find it 
+        @@data = YAML.load_file("./info.yaml")
+        @@project = @@data['(project)']
+        if @@project == nil
+            # TODO: maybe change this to be optional in the future and have default settings
+            raise "\n\nThere is no (project): key in the info.yaml\n(so ATK is unable to parse the project settings)"
+        end
+        # TODO: remove this
+        # @@project = Info.parse_language_evaluations(@@project)
+        
+        @@settings = @@project['(advanced_setup)']
+        if @@settings == nil
+            # TODO: maybe change this to be optional in the future and have default settings
+            raise "\n\nThere is no (advanced_setup): key in the (project) of the info.yaml\n(so ATK is unable to parse the project settings)"
+        end
+        Info.parse_advanced_setup(@@settings, @@settings)
+        @@dependencies               = @@settings['(dependencies)']
+        @@project_commands           = @@settings['(project_commands)']
+        @@structures                 = @@settings['(structures)']
+        @@local_package_managers     = @@settings['(local_package_managers)']
+        @@put_new_dependencies_under = @@settings['(put_new_dependencies_under)']
+        @@environment_variables      = @@settings['(environment_variables)']
+    end
+    
+    # accessors
+    def self.data()                       Info.load_if_needed; return @@data                        end
+    def self.project()                    Info.load_if_needed; return @@project                     end
+    def self.settings()                   Info.load_if_needed; return @@settings                    end
+    def self.dependencies()               Info.load_if_needed; return @@dependencies                end
+    def self.project_commands()           Info.load_if_needed; return @@project_commands            end
+    def self.structures()                 Info.load_if_needed; return @@structures                  end
+    def self.local_package_managers()     Info.load_if_needed; return @@local_package_managers      end
+    def self.put_new_dependencies_under() Info.load_if_needed; return @@put_new_dependencies_under  end
+    def self.environment_variables()      Info.load_if_needed; return @@environment_variables       end
+    
+    # read access to the yaml file
+    def self.[](element)
+        Info.load_if_needed
+        return @@data[element.to_s]
+    end
+end

data/lib/atk_toolbox.rb

@@ -0,0 +1,6 @@
+require_relative './atk/cmd'
+require_relative './atk/download'
+require_relative './atk/os'
+require_relative './atk/output'
+require_relative './atk/package_managers'
+require_relative './atk/yaml_info_parser'

data/test/info.yaml

@@ -0,0 +1,68 @@
+# Example of Project settings
+(using_atk_version): 1.0
+(project):
+    name: The ATK Repo
+    description: Blah
+    homepage: www.blah.com
+    
+    auto_generated_commands: &auto_generated_commands !evaluate/ruby |
+        commands = {}
+        # check for a scripts directory
+        script_file_paths = Dir["scripts/*"]
+        for each in script_file_paths
+            commands[File.basename(each, ".*")] = "./#{each}"
+        end
+        commands
+    
+    basic_setup: &basic_setup_reference
+        (project_commands): &basic_commands
+            # auto-insert the !lang/console if they dont put one
+            run: !language/ruby
+                puts "hi"
+            stop: \`pkill node`
+            compile: gcc *.cpp
+            # TODO: add inline support for doing things like auto-generating commands
+            ? !inline [ *auto_generated_commands ]
+        (environment_variables):
+            JAVA_VERSION: "8.9"
+        (structures):
+            npm-package: v1.0.0
+            vs-code-package: v1.0.0
+            git-repo: v1.0.0
+        (dependencies): &base_dependencies
+            python3: v3.7.0
+            node: v11.11.0
+            npm: v6.7.0
+            git: v2.21.0
+    
+    (advanced_setup):
+        (local_package_managers): ['npm', 'pip'] # by default the local package managers are always here
+        (put_new_dependencies_under): [ '(project)', 'basic_info', '(dependencies)' ]
+        <<: *basic_setup_reference # this injects all the (basic_setup) here
+        # caveats for a specific OS
+        when(--os is 'mac'):
+            (dependencies):
+                <<: *base_dependencies
+                python2: v2.7
+            
+        when(--os is 'windows'):
+            (project_commands):
+                <<: *basic_commands 
+                show_files: dir # this is a custom command specific to windows
+        when(--os is 'linux'):
+            # caveats for a specific OS sub-version
+            when(--os is 'arch'):
+                (project_commands):
+                    <<: *basic_commands # this injects all the (project_commands) here
+                    my_ip_address: "ip" # this is a custom command specific to arch linux
+                    
+        # # caveats for a different context
+        # when(--context is 'testing'):
+        #     (environment_variables):
+        #         CMAKE_LIB: "testing"
+        #     (project_commands):
+        #         run: node tests.rb
+            
+        #     when(--os is 'windows'):
+        #         (environment_variables):
+        #             CMAKE_LIB: "C:\\testing"

data/test/main.rb

@@ -0,0 +1,5 @@
+require 'atk_toolbox'
+
+Dir.chdir __dir__
+
+p Info.project_commands

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: atk_toolbox
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jeff Hykin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-06-06 00:00:00.000000000 Z
+dependencies: []
+description: ''
+email: jeff.hykin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/atk/cmd.rb
+- lib/atk/download.rb
+- lib/atk/os.rb
+- lib/atk/output.rb
+- lib/atk/package_managers.rb
+- lib/atk/yaml_info_parser.rb
+- lib/atk_toolbox.rb
+- test/info.yaml
+- test/main.rb
+homepage: http://github.com//atk-toolbox
+licenses:
+- CC-BY-ND-4.0
+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: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: The Ruby gem for all the standard tools ATK uses internally
+test_files: []