pinstripe 0.1.2

data/lib/pinstripe/monkey_patches/to_params_hash.rb

@@ -0,0 +1,20 @@
+
+require "pinstripe/params_hash"
+
+class Hash
+
+    def to_params_hash
+        Pinstripe::ParamsHash.new(self)
+    end
+
+end
+
+class Array
+
+    def to_params_hash
+        out = Pinstripe::ParamsHash.new
+        each_with_index{|value, key| out[key] = value}
+        out
+    end
+
+end

data/lib/pinstripe/params_hash.rb

@@ -0,0 +1,44 @@
+
+class Pinstripe::ParamsHash < Hash
+
+    def initialize(hash = {})
+       merge!(hash) 
+    end
+
+    def []=(key, value)
+        super(key.to_s, normalize_value(value))
+    end
+
+    def[](key)
+        super(key.to_s)
+    end
+
+    def merge!(hash)
+        hash.each{|key, value| self[key] = value }
+    end
+
+    def merge(hash)
+        out = clone
+        out.merge!(hash)
+        out
+    end
+
+    def method_missing(name, *args, &block)
+        if args.length == 0 && !block
+            self[name]
+        else
+            super
+        end
+    end
+
+    private
+
+    def normalize_value(value)
+        if value.respond_to? :to_params_hash
+            value.to_params_hash
+        else
+            value.to_s
+        end
+    end
+
+end

data/lib/pinstripe/project.rb

@@ -0,0 +1,29 @@
+
+require "bundler"
+
+class Pinstripe::Project
+
+    attr_reader :root_path, :load_paths
+
+    def initialize
+        @root_path = find_path(Dir.pwd, ".pinstripe")
+        @load_paths = $LOAD_PATH.map{|load_path| find_path(load_path, ".pinstripe") }.compact
+    end
+
+    private
+
+    def find_path(path, file_name)
+        current_path = path
+        while true
+            candidate_file_path = "#{current_path}/#{file_name}"
+            return current_path if File.file?(candidate_file_path)
+            if matches = current_path.match(/\A(.*)\/([^\/]+)\z/)
+                current_path = matches[1]
+            else
+                break
+            end
+        end
+        nil
+    end
+
+end

data/lib/pinstripe/registry.rb

@@ -0,0 +1,46 @@
+
+module Pinstripe::Registry
+
+    attr_reader :name
+
+    def registered?
+        registered_classes.values.include? self
+    end
+
+    def registered_classes
+        @registered_classes ||= superclass.respond_to?(:registered_classes) ? superclass.registered_classes : {}
+    end
+
+    def register(name, &block)
+        raise "Class has already been registered" if registered?
+        name = name.to_s
+        instance_eval{ @name = name }
+        registered_classes[name] = self
+        self
+    end
+
+    def define(name, *args, &block)
+        klass = Class.new(self)
+        klass.register(name, *args)
+        klass.class_eval(&block) if block
+        klass
+    end
+
+    def for(name, options = {})
+        name = name.to_s
+        registered_classes[name] || begin
+            klass = Class.new(self)
+            if options[:register_if_not_exists]
+                klass.register name
+            else
+                klass.instance_eval{ @name = name }
+            end
+            klass
+        end
+    end
+
+    def create(name, *args, &block)
+        self.for(name).new(*args, &block)
+    end
+
+end

data/lib/pinstripe/resource_factories/call_handler.rb

@@ -0,0 +1,8 @@
+
+Pinstripe::ResourceFactory.define "call_handler" do
+
+    def create
+        Pinstripe::CallHandler.new
+    end
+
+end

data/lib/pinstripe/resource_factories/env.rb

@@ -0,0 +1,9 @@
+
+Pinstripe::ResourceFactory.define "env" do
+
+    def create
+        {}
+    end
+
+end
+

data/lib/pinstripe/resource_factories/environment.rb

@@ -0,0 +1,8 @@
+
+Pinstripe::ResourceFactory.define "environment" do
+
+    def create
+        ENV["RACK_ENV"] || "development"
+    end
+
+end

data/lib/pinstripe/resource_factories/project.rb

@@ -0,0 +1,8 @@
+
+Pinstripe::ResourceFactory.define "project", :shared => true do
+
+    def create
+        Pinstripe::Project.new
+    end
+
+end

data/lib/pinstripe/resource_factory.rb

@@ -0,0 +1,32 @@
+
+require "pinstripe/registry"
+require "pinstripe/helper"
+
+class Pinstripe::ResourceFactory
+
+    extend Pinstripe::Registry
+
+    class << self
+        def register(name, options = {})
+            super(name)
+
+            @shared = options.to_params_hash.shared == "true"
+
+            Pinstripe::Helper.define name do
+                def call
+                    ::Pinstripe.resource_provider[self.class.name]
+                end
+            end
+        end
+
+        def shared?
+            @shared
+        end
+
+    end
+
+    def create
+
+    end
+
+end

data/lib/pinstripe/resource_provider.rb

@@ -0,0 +1,50 @@
+
+
+class Pinstripe::ResourceProvider
+
+    attr_reader :shared_resources
+
+    def initialize
+        @shared_resources = {}
+        @mutex = Mutex.new
+    end
+
+    def thead_resources
+        Thread.current["PINSTRIPE_RESOURCES"] ||= {}
+    end
+
+    def [](name)
+        name = name.to_s
+
+        return thead_resources[name] if !thead_resources[name].nil?
+        return shared_resources[name] if !shared_resources[name].nil?
+
+        resource_factory = Pinstripe::ResourceFactory.create(name)
+
+        if resource_factory.class.shared?
+            @mutex.synchronize { shared_resources[name] ||= resource_factory.create }
+            shared_resources[name]
+        else
+            thead_resources[name] = resource_factory.create
+            thead_resources[name]
+        end
+    end
+
+    def []=(name, value)
+        thead_resources[name.to_s] = value
+        self
+    end
+
+    def reset(shared = false, thread = true, &block)
+        previous_shared_resources = shared_resources
+        previous_thread_resources = thread_resources
+        @mutex.syncronize { @shared_resources = {} } if shared
+        Thread.current["PINSTRIPE_RESOURCES"] = {} if thread
+        if block
+            block.call
+            @mutex.synchronize { @shared_resources = previous_shared_resources } if shared
+            Thread.current["PINSTRIPE_RESOURCES"] = previous_thread_resources if thread
+        end
+    end
+
+end

data/lib/pinstripe/version.rb

@@ -0,0 +1,3 @@
+module Pinstripe
+  VERSION = "0.1.2"
+end

data/lib/pinstripe/workspace.rb

@@ -0,0 +1,8 @@
+
+require "pinstripe/helpers"
+
+class Pinstripe::Workspace
+
+    include Pinstripe::Helpers
+
+end

data/lib/pinstripe.rb

@@ -0,0 +1,24 @@
+
+require "pinstripe/monkey_patches/require_all"
+
+module Pinstripe
+    
+    require_all("pinstripe/monkey_patches")
+    require_all("pinstripe")
+
+    class << self
+
+        def resource_provider
+            @resource_provider ||= ResourceProvider.new
+        end
+
+        def call(env)
+            resource_provider.reset do
+                resource_provider["env"] = env
+                resource_provider["call_handler"].handle_call
+            end
+        end
+
+    end
+
+end

data/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "pinstripe",
+  "version": "0.1.0",
+  "main": "web/javascripts/bundle.js",
+  "module": "web/javascripts/_pinstripe/index.js",
+  "license": "MIT",
+  "scripts": {
+    "build": "rollup --config",
+    "clean": "rm -rf ./node_modules && rm -rf ./dist"
+  },
+  "devDependencies": {
+    "rollup": "^2.0.2",
+    "rollup-plugin-node-resolve": "^5.2.0"
+  }
+}

data/pinstripe

@@ -0,0 +1,4 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+load "#{__dir__}/exe/pinstripe"

data/pinstripe.gemspec

@@ -0,0 +1,38 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "pinstripe/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "pinstripe"
+  spec.version       = Pinstripe::VERSION
+  spec.authors       = ["Jody Salt"]
+  spec.email         = ["jody@jodysalt.com"]
+
+  spec.summary       = "An entrepreneurial full stack web framework!"
+  spec.license = "MIT"
+
+  #spec.description   = %q{TODO: Write a longer description or delete this line.}
+  #spec.homepage      = "TODO: Put your gem's website or public repo URL here."
+
+  #spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+  #spec.metadata["homepage_uri"] = spec.homepage
+  #spec.metadata["source_code_uri"] = "TODO: Put your gem's public repo URL here."
+  #spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "mysql2", "~> 0.5"
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  
+end

data/rollup.config.js

@@ -0,0 +1,19 @@
+
+import resolve from "rollup-plugin-node-resolve"
+
+export default [
+    {
+        input: 'web/javascripts/_pinstripe/index.js',
+        output: {
+            file: `web/javascripts/bundle.js`,
+            format: 'iife',
+            sourcemap: true
+        },
+        plugins: [resolve()],
+        onwarn(warning, warn) {
+            const ignoreCodes = ['EVAL', 'CIRCULAR_DEPENDENCY']
+            if (ignoreCodes.some(code => code == warning.code)) return
+            warn(warning)
+        }
+    }
+]

data/web/javascripts/_pinstripe/event_wrapper.js

@@ -0,0 +1,29 @@
+
+import { NodeWrapper } from './node_wrapper'
+
+export class EventWrapper {
+
+    static instanceFor(event){
+        if(!event.$p){
+            event.$p = new this(event)
+        }
+        return event.$p
+    }
+    
+    constructor(event){
+        this.event = event
+    }
+
+    get target(){
+        return NodeWrapper.instanceFor(this.event.target)
+    }
+
+    stopPropagation(){
+        this.event.stopPropagation()
+    }
+
+    preventDefault(){
+        this.event.preventDefault()
+    }
+
+}

data/web/javascripts/_pinstripe/index.js

@@ -0,0 +1,3 @@
+
+import './node_wrappers'
+import './initialize'

data/web/javascripts/_pinstripe/initialize.js

@@ -0,0 +1,29 @@
+
+import { NodeWrapper } from './node_wrapper'
+
+let ready = false;
+
+function initializeTree(node){
+    NodeWrapper.instanceFor(node).descendants
+}
+
+const observer = new MutationObserver(mutations => {
+    if(ready){
+        mutations.forEach(
+            mutation => mutation.addedNodes.forEach(
+                node => initializeTree(node)
+            )
+        )
+    }
+})
+
+observer.observe(document.documentElement, {
+    attributes: false,
+    childList: true,
+    subtree: true
+});
+
+setTimeout(() => {
+    ready = true
+    initializeTree(document)
+}, 0)