kanji-web 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 864b99448c021a5a6e386c1be615540b1a0094bb
+  data.tar.gz: 11fcc22cf234333a3ffb229a71483cebb0233d84
+SHA512:
+  metadata.gz: 109cb177d81512bef482275367e962ce5b04715bb7737ee9e9c2db7c86e4afacf26d9c691d8088ce29171ebc28d1a27e9e3c2fbca82d8b48c8d2818703b73ac6
+  data.tar.gz: 36d8b79e6d993098a966ab3d3aaaba29aa90cb146802bcf8876acaa06a4d5c65b6714d716ad805c616e704e83239fa2bf35554ec3824376a8e228c311c74a100

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Darin Haener
+
+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/Rakefile

@@ -0,0 +1 @@
+Dir.glob('lib/tasks/*.rake').each { |r| load r }

data/bin/kanji

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "kanji/cli"
+
+Kanji::CLI.start ARGV

data/lib/kanji.rb

@@ -0,0 +1,5 @@
+require "kanji/container"
+
+module Kanji
+
+end

data/lib/kanji/application.rb

@@ -0,0 +1,37 @@
+require "roda"
+require "roda/plugins/flow"
+require "dry-configurable"
+
+module Kanji
+  class Application < ::Roda
+    extend Dry::Configurable
+
+    setting :container, reader: true
+
+    plugin :render, views: "app/views"
+    plugin :error_handler
+    plugin :flow
+
+    def self.configure(&block)
+      super.tap do
+        use(container[:rack_monitor]) if container.config.listeners
+      end
+    end
+
+    def self.resolve(name)
+      container[name]
+    end
+
+    def self.[](name)
+      container[name]
+    end
+
+    def self.root
+      container.config.root
+    end
+
+    def notifications
+      self.class[:notifications]
+    end
+  end
+end

data/lib/kanji/cli.rb

@@ -0,0 +1,36 @@
+require "thor"
+
+module Kanji
+  class CLI < Thor
+    desc "new APP", "Generate a new Kanji project"
+    def new(app_name)
+      require "kanji/generators/project"
+      Generators::Project.new(app_name).call
+    end
+
+    map "n" => "new"
+
+    desc "generate GENERATOR", "Generate a new item for this project"
+    require "kanji/cli/generate"
+    subcommand "generate", CLI::Generate
+
+    map "g" => "generate"
+
+    desc "server", "Start the application server"
+    def server
+      `shotgun config.ru > stdout`
+    end
+
+    map "s" => "server"
+
+    desc "console", "Open up the application console"
+    def console
+      require "bundler/setup"
+      require "dry/web/console"
+      require_relative "#{Dir.pwd}/system/boot"
+      Dry::Web::Console.start
+    end
+
+    map "c" => "console"
+  end
+end

data/lib/kanji/cli/generate.rb

@@ -0,0 +1,13 @@
+require "thor"
+
+module Kanji
+  class CLI < Thor
+    class Generate < Thor
+      desc "type NAME ATTRIBUTES", "Generate a new type and all of it's dependencies"
+      def type(name, *attributes)
+        require "kanji/generators/type"
+        Generators::Type.new(name, attributes).call
+      end
+    end
+  end
+end

data/lib/kanji/container.rb

@@ -0,0 +1,12 @@
+require "dry/system/container"
+require "kanji/graph/container"
+
+module Kanji
+  class Container < Dry::System::Container
+    configure do |config|
+      config.root = Pathname.new("./")
+    end
+
+    load_paths!("lib/kanji/type", "lib/kanji/graph")
+  end
+end

data/lib/kanji/errors.rb

@@ -0,0 +1,10 @@
+module Kanji
+  class AttributeError < StandardError
+  end
+
+  class ValidationError < StandardError
+  end
+
+  class ArgumentError < StandardError
+  end
+end

data/lib/kanji/generate.rb

@@ -0,0 +1,48 @@
+require "pathname"
+require "thor"
+
+module Kanji
+  class Generate
+    TEMPLATES_DIR = "templates".freeze
+    SOURCE_DIR = Pathname(__FILE__).dirname.join(TEMPLATES_DIR)
+
+    attr_reader :target_dir, :template_scope, :template_files, :processor
+
+    def initialize(target_dir, template_scope)
+      @target_dir = target_dir
+      @template_scope = template_scope
+      @template_files = Dir[SOURCE_DIR.join('**/{.,}*')]
+
+      @processor = Class.new(Thor) do
+        include Thor::Actions
+      end.new
+      @processor.class.source_root SOURCE_DIR
+    end
+
+    def call(source, target)
+      source = Pathname(source)
+      aboslute_source_path = source.expand_path(SOURCE_DIR)
+      target_file = get_target_file(target)
+      template_file = template_files.find { |f| f == aboslute_source_path.to_s } or raise "missing template file +#{source}+"
+      template_file = Pathname(template_file)
+
+      processor.template template_file, target_file, template_scope
+
+      create_executable(target_file) if executable?(template_file)
+    end
+
+    private
+
+    def get_target_file(target)
+      Pathname.getwd.join(target_dir, target)
+    end
+
+    def create_executable(file)
+      FileUtils.chmod "a+x", file
+    end
+
+    def executable?(file)
+      file.file? && file.executable?
+    end
+  end
+end

data/lib/kanji/generators/abstract_generator.rb

@@ -0,0 +1,50 @@
+require "kanji/generate"
+require "dry/core/inflector"
+
+module Kanji
+  module Generators
+    class AbstractGenerator
+      def initialize(target_dir)
+        @target_dir = target_dir
+        @templates = []
+        populate_templates
+        @templates.freeze
+      end
+
+      def call
+        templates.each do |source, target|
+          generator.(source, target)
+        end
+
+        post_process_callback
+      end
+
+      private
+      attr_reader :target_dir, :templates
+
+      def populate_templates
+        fail NotImplementedError
+      end
+
+      def post_process_callback
+
+      end
+
+      def add_template(source, target)
+        templates << [source, target]
+      end
+
+      def generator
+        @generator ||= Generate.new(destination, template_scope)
+      end
+
+      def destination
+        fail NotImplementedError
+      end
+
+      def template_scope
+        fail NotImplementedError
+      end
+    end
+  end
+end

data/lib/kanji/generators/project.rb

@@ -0,0 +1,155 @@
+require "kanji/generate"
+require "kanji/generators/abstract_generator"
+require "dry/core/inflector"
+
+module Kanji
+  module Generators
+    class Project < AbstractGenerator
+      def initialize(app_name, options = {})
+        @app_name = app_name
+        super(underscored_project_name)
+      end
+
+      def populate_templates
+        add_bin
+        add_config
+        add_db
+        add_log
+        add_spec
+        add_app
+        add_lib
+        add_system
+        add_config_files
+      end
+
+      private
+      attr_reader :app_name
+
+      def post_process_callback
+        message = <<-TEXT
+\n
+You're now ready to start writing your Kanji app! Congratulations!
+Because this is a data driven API application, you can't do much
+with it until you create some types! Get started by using a generator:
+`kanji g type User email:string`
+
+This will generate a type and some mutations for you! Then you can:
+`rake db:create && rake db:migrate`
+
+After that open up `app/query_type.rb` and add a field to your root query
+type:
+
+field :users do
+  type -> { types[Types::User[:graphql_type]] }
+  description "All of the users for this app"
+
+  resolve -> (obj, args, ctx) { Types::User[:repo].all }
+end
+
+Now open up `app/schema.rb` and uncomment the lines that add the
+query and mutation types.
+
+Start your server: `kanji s` and visit `localhost:9393/graphiql` and
+start exploring!
+        TEXT
+
+        generator.processor.say(message, :cyan)
+      end
+
+      def destination
+        underscored_project_name
+      end
+
+      def template_scope
+        {
+          underscored_project_name: underscored_project_name,
+          camel_cased_app_name: camel_cased_app_name
+        }
+      end
+
+      def underscored_project_name
+        Dry::Core::Inflector.underscore(app_name)
+      end
+
+      def camel_cased_app_name
+        Dry::Core::Inflector.camelize(app_name)
+      end
+
+      def add_bin
+        add_template("bin/console.tt", "bin/console")
+        add_template("bin/setup", "bin/setup")
+      end
+
+      def add_config
+        add_template(".env.tt", ".env")
+        add_template(".env.test.tt", ".env.test")
+      end
+
+      def add_db
+        add_template("db/sample_data.rb", "db/sample_data.rb")
+        add_template("db/seed.rb", "db/seed.rb")
+      end
+
+      def add_app
+        add_template("app/types.rb.tt", "app/types.rb")
+        add_template("app/schema.rb.tt", "app/schema.rb")
+        add_template("app/query_type.rb.tt", "app/query_type.rb")
+        add_template("app/mutation_type.rb.tt", "app/mutation_type.rb")
+        add_template("app/views/graphiql.html.erb", "app/views/graphiql.html.erb")
+        add_template(".keep", "app/repositories/.keep")
+        add_template(".keep", "app/types/.keep")
+        add_template(".keep", "client/.keep")
+      end
+
+      def add_lib
+        add_template(".keep", "lib/.keep")
+      end
+
+      def add_log
+        add_template(".keep", "log/.keep")
+      end
+
+      def add_spec
+        add_template(".rspec", ".rspec")
+
+        # Base spec helpers
+        add_template("spec/db_spec_helper.rb.tt", "spec/db_spec_helper.rb")
+        add_template("spec/spec_helper.rb", "spec/spec_helper.rb")
+
+        # DB support
+        add_template("spec/support/db/factory.rb", "spec/support/db/factory.rb")
+        add_template("spec/support/db/helpers.rb.tt", "spec/support/db/helpers.rb")
+        add_template("spec/factories/example.rb", "spec/factories/example.rb")
+      end
+
+      def add_system
+        add_system_lib
+        add_system_boot
+      end
+
+      def add_system_lib
+        add_template("system/project/container.rb.tt", "system/#{underscored_project_name}/container.rb")
+        add_template("system/project/import.rb.tt", "system/#{underscored_project_name}/import.rb")
+        add_template("system/project/settings.rb.tt", "system/#{underscored_project_name}/settings.rb")
+        add_template("system/project/application.rb.tt", "system/#{underscored_project_name}/application.rb")
+      end
+
+      def add_system_boot
+        add_template("system/boot.rb.tt", "system/boot.rb")
+        add_template("system/boot/monitor.rb.tt", "system/boot/monitor.rb")
+        add_template("system/boot/rom.rb.tt", "system/boot/rom.rb")
+        add_template("system/boot/settings.rb.tt", "system/boot/settings.rb")
+        add_template("system/boot/graph.rb.tt", "system/boot/graph.rb")
+        add_template("system/boot/repos.rb.tt", "system/boot/repos.rb")
+      end
+
+      def add_config_files
+        add_template(".gitignore", ".gitignore")
+        add_template("Gemfile", "Gemfile")
+        add_template("Rakefile.tt", "Rakefile")
+        add_template("config.ru.tt", "config.ru")
+        add_template("README.md.tt", "README.md")
+      end
+    end
+  end
+end

data/lib/kanji/generators/type.rb

@@ -0,0 +1,110 @@
+require "thor"
+require "dry/core/inflector"
+require "kanji/generators/abstract_generator"
+
+module Kanji
+  module Generators
+    class Type < AbstractGenerator
+      def initialize(name, attributes)
+        @name = name
+        @attributes = attributes.map { |attr| attr.split(":") }
+        super(destination)
+      end
+
+      def populate_templates
+        add_type
+        add_repository
+        add_mutations
+        add_migration
+      end
+
+      private
+      attr_reader :name, :attributes
+
+      def template_scope
+        {
+          type_name: type_name,
+          pluralized_type_name: pluralized_type_name,
+          class_name: class_name,
+          pluralized_class_name: pluralized_class_name,
+          attributes: attributes,
+          application_class: application_class,
+          lookup_type: -> (name) { lookup_type(name) },
+          lookup_column_type: -> (name) { lookup_column_type(name) }
+        }
+      end
+
+      def add_type
+        add_template("app/types/type.rb.tt", "app/types/#{type_name}.rb")
+      end
+
+      def add_repository
+        add_template("app/repositories/repo.rb.tt", "app/repositories/#{pluralized_type_name}.rb")
+      end
+
+      def destination
+        "./"
+      end
+
+      def add_mutations
+        fields = "\n\n      field :create#{class_name}, Types::#{class_name}[:create_mutation]\n" +
+        "      field :update#{class_name}, Types::#{class_name}[:update_mutation]\n" +
+        "      field :destroy#{class_name}, Types::#{class_name}[:destroy_mutation]\n"
+
+        generator.processor.insert_into_file "./app/mutation_type.rb", fields, after: /description ".*"/
+      end
+
+      def add_migration
+        add_template("migration.rb.tt", "db/migrate/#{Time.now.strftime("%Y%m%d%H%M%S")}_create_#{pluralized_type_name}.rb")
+      end
+
+      def application_class
+        @_application_class ||= Dry::Core::Inflector.camelize(File.basename(Dir.pwd))
+      end
+
+      def type_name
+        @_type_name ||= Dry::Core::Inflector.underscore(name)
+      end
+
+      def pluralized_type_name
+        @_pluralized_type_name ||= Dry::Core::Inflector.pluralize(type_name)
+      end
+
+      def class_name
+        @_class_name ||= Dry::Core::Inflector.camelize(name)
+      end
+
+      def pluralized_class_name
+        @_pluralized_class_name ||= Dry::Core::Inflector.pluralize(class_name)
+      end
+
+      def lookup_type(type_name)
+        map = {
+          "string" => "Kanji::Types::String",
+          "integer" => "Kanji::Types::Int",
+          "decimal" => "Kanji::Types::Decimal",
+          "text" => "Kanji::Types::String",
+          "boolean" => "Kanji::Types::Bool",
+          "float" => "Kanji::Types::Float",
+          "datetime" => "Kanji::Types::DateTime"
+        }
+
+        map.fetch(type_name, "Kanji::Types::Any")
+      end
+
+      def lookup_column_type(type_name)
+        map = {
+          "string" => "varchar(255)",
+          "integer" => "integer",
+          "decimal" => "numeric",
+          "text" => "text",
+          "boolean" => "boolean",
+          "datetime" => "timestamp",
+          "float" => "double precision"
+        }
+
+        map.fetch(type_name, nil)
+      end
+    end
+  end
+end