chaplin 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 913d6d26f30963578fc07305f2a8c3165fcc54c5
+  data.tar.gz: 9651466b98f18f4ad9d9c746304f5f834a2598a1
+SHA512:
+  metadata.gz: 7748940639a04dd6cb00fc53fbf61646a69ff71fb7c72617ce831b1aa0b777342b0f7f1e164626498a3c44f61e8b046edbbf273946014f29ad49a6c104a68ce7
+  data.tar.gz: 387add2e988ad1800459294ce1acaf4d20da74dcab09199ba5b061945679ffa4f47f82121f468b8febb22957e81d29a0ed2bbe3d4f3b8df5c98c4744f7ee8878

data/bin/chaplin

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+require "rack"
+require_relative '../lib/chaplin'
+
+if ARGV[0].nil?
+  puts "usage:"
+  puts "$ chaplin my_chaplin_project_directory_name"
+  puts "or"
+  puts "$ chaplin new my_chaplin_project_directory_name"
+elsif ARGV[0] == 'new'
+  new_project_path = ARGV[1]
+
+  FileUtils.mkdir(new_project_path)
+  FileUtils.cp_r("#{__dir__}/../sample_project/.", new_project_path)
+
+  puts "New chaplin project created in #{new_project_path}"
+  puts "Start the server with '$ chaplin #{new_project_path}'"
+else
+  project_directory = ARGV[0]
+  chaplin_server = Chaplin.new(project_directory).server
+
+  Rack::Server.start(app: chaplin_server, Port: 8081)
+end

data/lib/chaplin/api_endpoint.rb

@@ -0,0 +1,69 @@
+require 'json'
+
+require 'faraday'
+require 'mustache'
+
+require_relative 'endpoint'
+
+class Chaplin
+  ApiEndpoint = Struct.new(:http_method, :path, :params, :headers) do
+
+    def initialize(http_method, path, params, headers = {})
+      super(http_method, path, params || {}, headers)
+    end
+
+    def self.configure(api_url, default_headers, basic_auth)
+      @@client = Faraday.new(url: api_url) do |client|
+        client.adapter Faraday.default_adapter
+        if basic_auth
+          client.basic_auth(basic_auth['user'], basic_auth['password'])
+        end
+      end
+      @@default_headers = default_headers || {}
+    end
+
+    def render(request_params)
+      response_body = api_response(request_params).body
+      return nil if (response_body == 'null' or response_body == '')
+      JSON.parse(response_body)
+    end
+
+    private
+
+    def api_response(request_params)
+      @@client.send(
+        http_method,
+        parsed_path(request_params),
+        api_request_params(request_params),
+        @@default_headers
+      )
+    end
+
+    def api_request_params(chaplin_request_params)
+      if json_request? && [:post, :put, :patch].include?(http_method)
+        Mustache.render(params.to_json, chaplin_request_params)
+      else
+        rendered_params(chaplin_request_params)
+      end
+    end
+
+    def json_request?
+      request_headers['Content-Type'] == 'application/json'
+    end
+
+    def request_headers
+      @@default_headers.merge(headers)
+    end
+
+    def rendered_params(request_params)
+      params.each_with_object({}) do |(key, value), rendered_params|
+        rendered_params[key] = Mustache.render(value, request_params)
+      end
+    end
+
+    def parsed_path(request_params)
+      Mustache.render(path, request_params)
+    end
+  end
+end
+

data/lib/chaplin/endpoint.rb

@@ -0,0 +1 @@
+Endpoint = Struct.new(:http_method, :path)

data/lib/chaplin/parser/api_endpoints.rb

@@ -0,0 +1,46 @@
+require_relative '../api_endpoint'
+
+class Chaplin
+
+  module Parser
+
+    class ApiEndpoints
+
+      def self.build(api_endpoint_declaration)
+        new(api_endpoint_declaration).build
+      end
+
+      def initialize(api_endpoint_declaration)
+        @api_endpoint_declaration = [api_endpoint_declaration].flatten
+      end
+
+      def build
+        ApiEndpoint.new(http_method, path, params, headers)
+      end
+
+      private
+
+      def http_method
+        api_route.first.downcase.to_sym
+      end
+
+      def path
+        api_route.last
+      end
+
+      def api_route
+        @api_endpoint_declaration.first.split(" ")
+      end
+
+      def params
+        @api_endpoint_declaration[1] || {}
+      end
+
+      def headers
+        @api_endpoint_declaration[2] || {}
+      end
+
+    end
+  end
+end
+

data/lib/chaplin/parser/config.rb

@@ -0,0 +1,50 @@
+require 'json'
+
+class Chaplin
+  module Parser
+
+    Config = Struct.new(:project_path) do
+
+      DEFAULT_API_URL = "http://localhost:8080"
+
+      def api_url
+        config['api_url'] || DEFAULT_API_URL
+      end
+
+      def default_headers
+        config['headers']
+      end
+
+      def basic_auth
+        config['basic_auth']
+      end
+
+      private
+
+      def config
+        @config ||= load_yaml || load_json || {}
+      end
+
+      def load_yaml
+        if File.exists?(yaml_filename)
+          YAML.load_file(yaml_filename)
+        end
+      end
+
+      def yaml_filename
+        "#{project_path}/chaplin_config.yml"
+      end
+
+      def load_json
+        if File.exists?(json_filename)
+          JSON.load(File.open(json_filename))
+        end
+      end
+
+      def json_filename
+        "#{project_path}/chaplin_config.json"
+      end
+
+    end
+  end
+end

data/lib/chaplin/parser/declaration_file.rb

@@ -0,0 +1,45 @@
+require 'pathname'
+require 'json'
+require 'yaml'
+
+class Chaplin
+  module Parser
+    DeclarationFile = Struct.new(:project_path) do
+
+      def self.app_declaration(project_path)
+        new(project_path).app_declaration
+      end
+
+      def app_declaration
+        load_json || load_yaml || no_file_found
+      end
+
+      private
+
+      def load_json
+        if File.exists?(json_filename)
+          JSON.load(File.open(json_filename))
+        end
+      end
+
+      def json_filename
+        project_path + "/routes.json"
+      end
+
+      def load_yaml
+        if File.exists?(yml_filename)
+          YAML.load_file(yml_filename)
+        end
+      end
+
+      def yml_filename
+        project_path + "/app.yml"
+      end
+
+      def no_file_found
+        raise "Could not find #{yml_filename} or #{json_filename}"
+      end
+
+    end
+  end
+end

data/lib/chaplin/parser/pages.rb

@@ -0,0 +1,76 @@
+require_relative '../responses/page'
+require_relative 'api_endpoints'
+
+class Chaplin
+  module Parser
+
+    Pages = Struct.new(:pages_data, :project_path, :layout_name) do
+
+      def self.load(pages_data, project_path, layout_name = nil)
+        new(pages_data, project_path, layout_name).tap do |pages|
+          pages.load
+        end
+      end
+
+      def load
+        @pages = {}
+
+        pages_data.each do |template_name, raw_data_hash|
+          @pages[template_name] = build_page(template_name, raw_data_hash)
+        end
+
+        return unless layout_name
+        @pages = @pages.each_with_object({}) do |(page_name, page), pages_in_layout|
+          pages_in_layout[page_name] = embed_in_layout(page)
+        end
+      end
+
+      def [](page_name)
+        @pages[page_name] || build_templated_page(page_name)
+      end
+
+      private
+
+      def embed_in_layout(page)
+        Responses::Page.new(layout_path, { content: page })
+      end
+
+      def build_page(template_name, raw_data_hash)
+        Responses::Page.new(template_path(template_name), data_hash(raw_data_hash))
+      end
+
+      def build_templated_page(page_name, raw_data_hash: {})
+        page = build_page(page_name, raw_data_hash)
+        layout_name ? embed_in_layout(page) : page
+      end
+
+      def template_path(template_name)
+        project_path + '/templates/' + template_name
+      end
+
+      def layout_path
+        @layout_path ||= template_path(layout_name)
+      end
+
+      def data_hash(raw_data_hash)
+        raw_data_hash.each_with_object({}) do |(key, raw_data_value), data_hash|
+          data_hash[key] = build_data(raw_data_value)
+        end
+      end
+
+      def build_data(raw_data_value)
+        if partial?(raw_data_value)
+          @pages[raw_data_value]
+        else
+          ApiEndpoints.build(raw_data_value)
+        end
+      end
+
+      def partial?(raw_data_value)
+        raw_data_value.is_a?(String) && !raw_data_value.include?(' ')
+      end
+
+    end
+
+  end
+end

data/lib/chaplin/parser/redirects.rb

@@ -0,0 +1,29 @@
+require_relative '../responses/redirect'
+require_relative 'api_endpoints'
+
+class Chaplin
+  module Parser
+
+    Redirects = Struct.new(:redirect_declarations) do
+
+      def self.load(redirect_declarations)
+        new(redirect_declarations).load
+      end
+
+      def load
+        redirect_declarations.each_with_object({}) do |(redirect_name, redirect_data), redirects_hash|
+          redirects_hash[redirect_name.to_s] = Responses::Redirect.new(redirect_data['path'], api_requests(redirect_data['requests']))
+        end
+      end
+
+      private
+
+      def api_requests(raw_requests_data)
+        raw_requests_data.each_with_object({}) do |(key, request_declaration), data_hash|
+          data_hash[key] = ApiEndpoints.build(request_declaration)
+        end
+      end
+
+    end
+  end
+end

data/lib/chaplin/parser/router.rb

@@ -0,0 +1,47 @@
+require 'json'
+
+require_relative '../endpoint'
+
+class Chaplin
+  module Parser
+
+    class Router
+
+      def initialize(routes_declarations, pages, redirects)
+        @routes_declarations = routes_declarations
+        @pages = pages
+        @redirects = redirects
+      end
+
+      def routes
+        {}.tap do |routes|
+          @routes_declarations.each do |endpoint, response_name|
+            routes[build_endpoint(endpoint)] = response(response_name)
+          end
+        end
+      end
+
+      private
+
+      def response(response_name)
+        if redirect?(response_name)
+          redirect_name = response_name.split(' ').last
+          @redirects[redirect_name]
+        else
+          @pages[response_name]
+        end
+      end
+
+      def redirect?(response)
+        response.start_with?("redirect")
+      end
+
+      def build_endpoint(raw_endpoint_data)
+        http_method = raw_endpoint_data.split(' ').first.downcase.to_sym
+        path = raw_endpoint_data.split(' ').last
+        Endpoint.new(http_method, path)
+      end
+
+    end
+  end
+end

data/lib/chaplin/parser.rb

@@ -0,0 +1,55 @@
+require_relative 'parser/declaration_file'
+require_relative 'parser/router'
+require_relative 'parser/pages'
+require_relative 'parser/redirects'
+
+class Chaplin
+  module Parser
+
+    def self.routes(project_path)
+      parser.routes(project_path)
+    end
+
+    def self.parser
+      Object.new.extend(self)
+    end
+
+    def routes(project_path)
+      self.project_path = project_path
+      Router.new(routes_declaration, pages, redirects).routes
+    end
+
+    private
+
+    attr_accessor :project_path
+
+    def pages
+      Pages.load(pages_declaration, project_path, layout_name)
+    end
+
+    def redirects
+      Redirects.load(redirects_declaration)
+    end
+
+    def pages_declaration
+      app_declaration['pages'] || []
+    end
+
+    def redirects_declaration
+      app_declaration['redirects'] || {}
+    end
+
+    def layout_name
+      app_declaration['layout']
+    end
+
+    def routes_declaration
+      app_declaration['routes']
+    end
+
+    def app_declaration
+      @app_declaration ||= DeclarationFile.app_declaration(project_path)
+    end
+
+  end
+end

data/lib/chaplin/responses/page.rb

@@ -0,0 +1,29 @@
+require 'mustache'
+
+class Chaplin
+  module Responses
+
+    # data is a hash with symbols as keys and api endpoints or other pages as values
+    Page = Struct.new(:template_path, :data) do
+
+      def execute(request_params, sinatra_server)
+        render(request_params)
+      end
+
+      def render(request_params)
+        page = Mustache.new
+        page.template_file = template_path
+        page.render(rendered_data(request_params).merge({params: request_params}))
+      end
+
+      private
+
+      def rendered_data(request_params)
+        data.each_with_object({}) do |(key, response), rendered_data|
+          rendered_data[key] = response.render(request_params)
+        end
+      end
+    end
+  end
+end
+

data/lib/chaplin/responses/redirect.rb

@@ -0,0 +1,28 @@
+require 'mustache'
+
+class Chaplin
+  module Responses
+
+    Redirect = Struct.new(:redirect_path, :api_requests_hash) do
+
+      def execute(request_params, sinatra_server)
+        rendered_api_data = rendered_data(request_params)
+
+        sinatra_server.redirect(rendered_path(rendered_api_data, request_params))
+      end
+
+      private
+
+      def rendered_data(request_params)
+        api_requests_hash.each_with_object({}) do |(key, value), rendered_data|
+          rendered_data[key] = value.render(request_params)
+        end
+      end
+
+      def rendered_path(rendered_data, request_params)
+        Mustache.render(redirect_path, rendered_data.merge(request_params))
+      end
+
+    end
+  end
+end

data/lib/chaplin/server.rb

@@ -0,0 +1,16 @@
+require 'sinatra/base'
+
+class Chaplin
+  class Server < Sinatra::Base
+
+    def self.setup(project_path)
+      set :public_folder, project_path + '/public'
+    end
+
+    def self.add_route(endpoint, response)
+      send(endpoint.http_method, endpoint.path) do
+        response.execute(params, self)
+      end
+    end
+  end
+end

data/lib/chaplin.rb

@@ -0,0 +1,29 @@
+require_relative 'chaplin/parser'
+require_relative 'chaplin/parser/config'
+require_relative 'chaplin/server'
+require_relative 'chaplin/api_endpoint'
+
+class Chaplin
+
+  def initialize(project_path)
+    @project_path = project_path
+    @config = Parser::Config.new(@project_path)
+  end
+
+  def server
+    ApiEndpoint.configure(@config.api_url, @config.default_headers, @config.basic_auth)
+    Server.setup(@project_path)
+    build_server
+    Server.new
+  end
+
+  private
+
+  def build_server
+    Parser.routes(@project_path).each do |endpoint, response|
+      Server.add_route(endpoint, response)
+    end
+  end
+
+end
+

metadata

@@ -0,0 +1,256 @@
+--- !ruby/object:Gem::Specification
+name: chaplin
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Victor Mours
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mustache
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-preloader
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: relish
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: childprocess
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Chaplin maps JSON APIs to Mustache templates to quickly create HTML apps,
+  without writing glue code.
+email: victor.mours@gmail.com
+executables:
+- chaplin
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/chaplin
+- lib/chaplin.rb
+- lib/chaplin/api_endpoint.rb
+- lib/chaplin/endpoint.rb
+- lib/chaplin/parser.rb
+- lib/chaplin/parser/api_endpoints.rb
+- lib/chaplin/parser/config.rb
+- lib/chaplin/parser/declaration_file.rb
+- lib/chaplin/parser/pages.rb
+- lib/chaplin/parser/redirects.rb
+- lib/chaplin/parser/router.rb
+- lib/chaplin/responses/page.rb
+- lib/chaplin/responses/redirect.rb
+- lib/chaplin/server.rb
+homepage: https://github.com/victormours/chaplin
+licenses:
+- MIT
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Build HTML apps from JSON APIs in no time
+test_files: []
+has_rdoc: