pinstripe 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f2cb947e0311ba670442c2bc3863299bf54c9d918420b44b1ebc52f8fe58b5d9
+  data.tar.gz: 50acc4e1919747618d584a0866e5226d58493d3e512fbd10828687c24213b884
+SHA512:
+  metadata.gz: fed3bc212e47bc4a7eab9ffc39f4474d15511edb44216da14196801615b059be9e6993edb67e90f593c1b5b9e8610487b63ee996312460132feeee3673c26e9f
+  data.tar.gz: e84b52f0d8d53235a21452eda448c87639b9b22d38898a971ca94fccd251e09771e53faefbb4611feb642bb430e29c4052ac5a6fea5a1de01741852da29e5c98

data/.gitignore

@@ -0,0 +1,5 @@
+
+
+node_modules/
+pkg/
+web/javascripts/bundle.*

data/.pinstripe

@@ -0,0 +1,3 @@
+{
+    "name" => "pinstripe"
+}

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in pinstripe.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,24 @@
+PATH
+  remote: .
+  specs:
+    pinstripe (0.1.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    minitest (5.14.0)
+    mysql2 (0.5.3)
+    rake (13.0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  minitest (~> 5.0)
+  mysql2 (~> 0.5)
+  pinstripe!
+  rake (~> 13.0)
+
+BUNDLED WITH
+   2.0.2

data/LICENSE

@@ -0,0 +1,20 @@
+
+Copyright (c) 2020 Jody Salt
+
+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,5 @@
+
+# Pinstripe Suit
+
+Welcome to Pinstripe. An entrepreneurial full stack web framework!
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/exe/pinstripe

@@ -0,0 +1,4 @@
+
+require("pinstripe")
+
+Pinstripe::Command.run(*ARGV)

data/lib/pinstripe/call_handler.rb

@@ -0,0 +1,12 @@
+
+require "pinstripe/helpers"
+
+class Pinstripe::CallHandler
+
+    include Pinstripe::Helpers
+
+    def handle_call
+        [200, {"Content-Type" => "text/plain"}, ["Hello World!"]]
+    end
+
+end

data/lib/pinstripe/command.rb

@@ -0,0 +1,20 @@
+
+require "pinstripe/registry"
+
+class Pinstripe::Command
+
+    extend Pinstripe::Registry
+    
+    def initialize(*args)
+
+    end
+
+    def self.run(name = 'list-commands', *args)
+        create(name, *args).run
+    end
+
+    def run
+        puts "No such command \"#{self.class.name}\""
+    end
+
+end

data/lib/pinstripe/commands/list_commands.rb

@@ -0,0 +1,16 @@
+
+require "pinstripe/command"
+
+Pinstripe::Command.define "list-commands" do
+
+    def run
+        puts ""
+        puts "The following commands are available:"
+        puts ""
+        Pinstripe::Command.registered_classes.keys.sort.each do |name|
+            puts "  * #{name}"
+        end
+        puts ""
+    end
+
+end

data/lib/pinstripe/commands/start_console.rb

@@ -0,0 +1,14 @@
+
+require "pinstripe/command"
+
+Pinstripe::Command.define "start-console" do
+
+    def run
+        require "irb"
+        IRB.setup nil
+        IRB.conf[:MAIN_CONTEXT] = IRB::Irb.new.context
+        require "irb/ext/multi-irb"
+        IRB.irb nil, Pinstripe::Workspace.new
+    end
+
+end

data/lib/pinstripe/concern.rb

@@ -0,0 +1,19 @@
+
+module Pinstripe::Concern
+    
+    def missing_method_calls
+        @missing_method_calls ||= []
+    end
+
+    def included(_module)
+        missing_method_calls.each do |missing_method_call|
+            args, block = missing_method_call
+            _module.send *args, &block
+        end
+    end
+
+    def method_missing(*args, &block)
+        missing_method_calls << [args, block]
+    end
+
+end

data/lib/pinstripe/database/row.rb

@@ -0,0 +1,48 @@
+
+class Pinstripe::Database::Row
+
+    extend Pinstripe::Registry
+
+    class << self
+
+        attr_accessor :table_class
+
+        def register(name, options = {})
+            if options[:abstract]
+                union_class = Pinstripe::Database::Union.for(name.pluralize, :register_if_not_exists => true)
+                union_class.table_classes << table_class if !union_class.table_classes.include?(table_class)
+            else
+                super(name)
+                @table_class = Pinstripe::Database::Table.for(name.pluralize, :register_if_not_exists => true)
+                field "id", "type" => "integer"
+            end
+        end
+
+        def has_many(name, *args, &block)
+           table_class.has_many(name, *args, &block)
+           class_eval("def #{name}; self.class.table_class.new(@database).id_eq(id).#{name}; end")
+        end
+
+        def has_one(name, *args, &block)
+            table_class.has_one(name, *args, &block)
+            class_eval("def #{name}; self.class.table_class.new(@database).id_eq(id).#{name}.first; end")
+        end
+
+        def belongs_to(name, *args, &block)
+            table_class.belongs_to(name, *args, &block)
+            class_eval("def #{name}; self.class.table_class.new(@database).id_eq(id).#{name}.first; end")
+        end
+
+        def field(*args, &block)
+            table_class.column(*args, &block)
+        end
+
+    end
+
+    def initialize(database, data = {})
+        @database = database
+        @data = data
+        @altered_data = {}
+    end
+
+end

data/lib/pinstripe/database/table.rb

@@ -0,0 +1,131 @@
+
+require "pinstripe/registry"
+
+class Pinstripe::Database::Table
+
+    extend Pinstripe::Registry
+
+    class << self
+
+        def relationships
+            @relationships ||= {}.to_params_hash
+        end
+
+        def has_many(name, options = {})
+            relationships[name] = {
+                "name" => name.to_s,
+                "collection_name" => name.to_s,
+                "from_key" => "id",
+                "to_key" => "#{self.name.singularize}_id",
+                "cascade_delete" => "true"
+            }
+            relationships[name].merge!(options)
+            class_eval("def #{name}; join('#{name}'); end")
+        end
+
+        def has_one(name, options = {})
+            relationships[name] = {
+                "name" => name.to_s,
+                "collection_name" => name.pluralize,
+                "from_key" => "id",
+                "to_key" => "#{self.name.singularize}_id",
+                "cascade_delete" => "true"
+            }
+            relationships[name].merge!(options)
+            class_eval("def #{name}; join('#{name}'); end")
+        end
+
+        def belongs_to(name, options = {})
+            relationships[name] = {
+                "name" => name.to_s,
+                "collection_name" => name.pluralize,
+                "from_key" => "#{name}_id",
+                "to_key" => "id",
+                "cascade_delete" => "false"
+            }
+            relationships[name].merge!(options)
+            class_eval("def #{name}; join('#{name}'); end")
+        end
+
+        def columns
+            @columns ||= {}.to_params_hash
+        end
+
+        def column(name, options = {})
+            columns[name] = {
+                "name" => name.to_s,
+                "type" => "string"
+            }
+            columns[name].merge!(options)
+            class_eval("def #{name}_eq(value); where('?.`#{name}` = ?', self, value); end")
+        end
+
+        def scope(name, &block)
+            #call block with join parents as arguments
+        end
+
+    end
+
+    def initialize(database, join_parent = nil, join_relationship_name = nil, table_alias_manager = Pinstripe::Database::TableAliasManager.new)
+        @database = database
+        @join_parent = join_parent
+        @join_relationship_name = join_relationship_name
+        @table_alias_manager = table_alias_manager
+        @joins = []
+        @predicates = []
+        @alias = table_alias_manager.generate_alias(self.class.name)
+    end
+
+    def clone
+        out = super
+        out.instance_eval do
+            @joins = @joins.clone
+            @predicates = @predicates.clone
+        end
+        out
+    end
+
+    def back(count = 1)
+        current = self
+        count.times do
+            previous = current
+            current = current.instance_eval{ @join_parent }.clone
+            current.instance_eval{ @joins << previous }
+        end
+        current
+    end
+
+    def join(relationship_name)
+        collection_name = self.class.relationships[relationship_name].collection_name
+        Pinstripe::Database::Table.create(collection_name, @database, self, relationship_name, @table_alias_manager)
+    end
+
+    def where(*predicate)
+        out = clone
+        out.instance_eval{ @predicates << predicate.flatten }
+        out
+    end
+
+    def first
+
+    end
+
+    def each
+
+    end
+
+    def all
+
+    end
+
+    def generate_predicate_sql
+        out = []
+
+        out.join(' and ')
+    end
+
+    def generate_select_sql
+
+    end
+
+end

data/lib/pinstripe/database/table_alias_manager.rb

@@ -0,0 +1,20 @@
+
+class Pinstripe::Database::TableAliasManager
+
+    def initialize
+        @alias_counters = {}
+    end
+
+    def generate_alias(name)
+        name = name.to_s
+        @alias_counters[name] = 0 if @alias_counters[name].nil?
+        @alias_counters[name] += 1
+
+        if @alias_counters[name] == 1
+            name
+        else
+            "#{name}#{@alias_counters[name]}"
+        end
+    end
+    
+end

data/lib/pinstripe/database/union.rb

@@ -0,0 +1,20 @@
+
+require "pinstripe/registry"
+
+class Pinstripe::Database::Union
+
+    extend Pinstripe::Registry
+
+    class << self
+
+        def table_classes
+            @table_classes ||= []
+        end
+
+    end
+
+    def initialize(database)
+        @database = database
+    end
+
+end

data/lib/pinstripe/database.rb

@@ -0,0 +1,56 @@
+
+require "mysql2"
+
+class Pinstripe::Database
+    
+    attr_reader :config
+
+    def initialize(config = {})
+        @config = config.to_params_hash
+    end
+
+    def client
+        @client ||= Mysql2::Client.new({
+            :host => @config.host || '127.0.0.1',
+            :port => @config.port || 3306,
+            :username => @config.username || 'root',
+            :password => @config.password || '',
+            :database => @config.name
+        })
+    end
+
+    def query(*query)
+        out = []
+        query = query.flatten
+        while(query.length > 0)
+            sql_fragment = query.shift.to_s
+            sql_fragment.gsub! /\?/ do |match|
+                value = query.shift
+                if value.kind_of?(Pinstripe::Database::Table)
+                    value.instance_eval{ @alias }
+                else
+                    sanitize(value)
+                end
+            end
+            out << sql_fragment
+        end
+        out.join(' ')
+    end
+
+    def sanitize(value)
+        value.kind_of?(Numeric) ? value : "'#{client.escape(value)}'"
+    end
+
+    def method_missing(name, *args, &block)
+        if args.length == 0
+            if Union.registered_classes[name]
+                Union.create(name, self)
+            else
+                Table.create(name, self)
+            end
+        else
+            super
+        end
+    end
+
+end

data/lib/pinstripe/helper.rb

@@ -0,0 +1,20 @@
+
+require "pinstripe/registry"
+require "pinstripe/helpers"
+
+class Pinstripe::Helper
+
+    extend Pinstripe::Registry
+    
+    include Pinstripe::Helpers
+    
+    def self.register(name)
+        super
+        Pinstripe::Helpers.class_eval("def #{name}(*args, &block); ::Pinstripe::Helper.create(\"#{name}\").call(*args, &block); end")
+    end
+
+    def call(*args, &block)
+
+    end
+
+end

data/lib/pinstripe/helpers.rb

@@ -0,0 +1,8 @@
+
+module Pinstripe::Helpers
+
+    def database
+        @database ||= Pinstripe::Database.new
+    end
+
+end

data/lib/pinstripe/inflector/inflections.rb

@@ -0,0 +1,122 @@
+
+module Pinstripe::Inflector::Inflections
+
+    instance_eval do
+        @pluralize_rules = []
+        @singularize_rules = []
+    end
+
+    class << self
+
+        attr_accessor :pluralize_rules
+        attr_accessor :singularize_rules
+
+        def plural(*args)
+            pluralize_rules.prepend(args)
+        end
+
+        def singular(*args)
+            singularize_rules.prepend(args)
+        end
+
+        def irregular(singular, plural)
+            s0 = singular[0]
+            srest = singular[1..-1]
+
+            p0 = plural[0]
+            prest = plural[1..-1]
+
+            if s0.upcase == p0.upcase
+                plural(/(#{s0})#{srest}$/i, '\1' + prest)
+                plural(/(#{p0})#{prest}$/i, '\1' + prest)
+
+                singular(/(#{s0})#{srest}$/i, '\1' + srest)
+                singular(/(#{p0})#{prest}$/i, '\1' + srest)
+            else
+                plural(/#{s0.upcase}(?i)#{srest}$/,   p0.upcase   + prest)
+                plural(/#{s0.downcase}(?i)#{srest}$/, p0.downcase + prest)
+                plural(/#{p0.upcase}(?i)#{prest}$/,   p0.upcase   + prest)
+                plural(/#{p0.downcase}(?i)#{prest}$/, p0.downcase + prest)
+
+                singular(/#{s0.upcase}(?i)#{srest}$/,   s0.upcase   + srest)
+                singular(/#{s0.downcase}(?i)#{srest}$/, s0.downcase + srest)
+                singular(/#{p0.upcase}(?i)#{prest}$/,   s0.upcase   + srest)
+                singular(/#{p0.downcase}(?i)#{prest}$/, s0.downcase + srest)
+            end
+        end
+
+        def uncountable(singular_and_plural)
+            irregular(singular_and_plural, singular_and_plural)
+        end
+
+    end
+
+    plural(/$/, "s")
+    plural(/s$/i, "s")
+    plural(/^(ax|test)is$/i, '\1es')
+    plural(/(octop|vir)us$/i, '\1i')
+    plural(/(octop|vir)i$/i, '\1i')
+    plural(/(alias|status)$/i, '\1es')
+    plural(/(bu)s$/i, '\1ses')
+    plural(/(buffal|tomat)o$/i, '\1oes')
+    plural(/([ti])um$/i, '\1a')
+    plural(/([ti])a$/i, '\1a')
+    plural(/sis$/i, "ses")
+    plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves')
+    plural(/(hive)$/i, '\1s')
+    plural(/([^aeiouy]|qu)y$/i, '\1ies')
+    plural(/(x|ch|ss|sh)$/i, '\1es')
+    plural(/(matr|vert|ind)(?:ix|ex)$/i, '\1ices')
+    plural(/^(m|l)ouse$/i, '\1ice')
+    plural(/^(m|l)ice$/i, '\1ice')
+    plural(/^(ox)$/i, '\1en')
+    plural(/^(oxen)$/i, '\1')
+    plural(/(quiz)$/i, '\1zes')
+
+    singular(/s$/i, "")
+    singular(/(ss)$/i, '\1')
+    singular(/(n)ews$/i, '\1ews')
+    singular(/([ti])a$/i, '\1um')
+    singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)(sis|ses)$/i, '\1sis')
+    singular(/(^analy)(sis|ses)$/i, '\1sis')
+    singular(/([^f])ves$/i, '\1fe')
+    singular(/(hive)s$/i, '\1')
+    singular(/(tive)s$/i, '\1')
+    singular(/([lr])ves$/i, '\1f')
+    singular(/([^aeiouy]|qu)ies$/i, '\1y')
+    singular(/(s)eries$/i, '\1eries')
+    singular(/(m)ovies$/i, '\1ovie')
+    singular(/(x|ch|ss|sh)es$/i, '\1')
+    singular(/^(m|l)ice$/i, '\1ouse')
+    singular(/(bus)(es)?$/i, '\1')
+    singular(/(o)es$/i, '\1')
+    singular(/(shoe)s$/i, '\1')
+    singular(/(cris|test)(is|es)$/i, '\1is')
+    singular(/^(a)x[ie]s$/i, '\1xis')
+    singular(/(octop|vir)(us|i)$/i, '\1us')
+    singular(/(alias|status)(es)?$/i, '\1')
+    singular(/^(ox)en/i, '\1')
+    singular(/(vert|ind)ices$/i, '\1ex')
+    singular(/(matr)ices$/i, '\1ix')
+    singular(/(quiz)zes$/i, '\1')
+    singular(/(database)s$/i, '\1')
+
+    irregular("person", "people")
+    irregular("man", "men")
+    irregular("child", "children")
+    irregular("sex", "sexes")
+    irregular("move", "moves")
+    irregular("zombie", "zombies")
+
+    uncountable "equipment"
+    uncountable "information"
+    uncountable "rice"
+    uncountable "money"
+    uncountable "species"
+    uncountable "series"
+    uncountable "fish"
+    uncountable "sheep"
+    uncountable "jeans"
+    uncountable "police"
+
+end

data/lib/pinstripe/inflector.rb

@@ -0,0 +1,28 @@
+
+
+module Pinstripe::Inflector
+
+    require "pinstripe/inflector/inflections"
+
+    class << self
+
+        def pluralize(word)
+            word = word.to_s
+            Inflections.pluralize_rules.each do |rule|
+                pattern, replacement = rule
+                return word.sub(pattern, replacement) if word.match?(pattern)
+            end
+        end
+
+        def singularize(word)
+            word = word.to_s
+            Inflections.singularize_rules.each do |rule|
+                pattern, replacement = rule
+                return word.sub(pattern, replacement) if word.match?(pattern)
+            end
+        end
+
+    end
+
+
+end

data/lib/pinstripe/monkey_patches/pluralize.rb

@@ -0,0 +1,8 @@
+
+class Object
+
+    def pluralize
+        Pinstripe::Inflector.pluralize(to_s)
+    end
+
+end

data/lib/pinstripe/monkey_patches/require_all.rb

@@ -0,0 +1,18 @@
+
+module Kernel
+
+    def require_all(path)
+        $LOAD_PATH.each do |current_load_path|
+            candidate_path = "#{current_load_path}/#{path}"
+            require path if File.exists?("#{candidate_path}.rb") || File.exists?("#{candidate_path}.ruby")
+
+            if Dir.exists?(candidate_path)
+                Dir.open(candidate_path).each do |item|
+                    item = item.sub(/(\.[^\.]+)$/, '')
+                    require_all("#{path}/#{item}") if item != '..' && item != '.'
+                end
+            end
+        end
+    end
+
+end

data/lib/pinstripe/monkey_patches/singularize.rb

@@ -0,0 +1,8 @@
+
+class Object
+
+    def singularize
+        Pinstripe::Inflector.singularize(to_s)
+    end
+
+end