text: # Copyright (c) 2014-present PlatformIO <contact@platformio.org>
  #
  # Licensed under the Apache License, Version 2.0 (the "License");
  # you may not use this file except in compliance with the License.
  # You may obtain a copy of the License at
  #
  #    http://www.apache.org/licenses/LICENSE-2.0
  #
  # Unless required by applicable law or agreed to in writing, software
  # distributed under the License is distributed on an "AS IS" BASIS,
  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  # See the License for the specific language governing permissions and
  # limitations under the License.
  
  import codecs
  import os
  import sys
  
  import bottle
  
  from platformio import fs, util
  from platformio.proc import where_is_program
  from platformio.project.helpers import load_project_ide_data
  
  
  class ProjectGenerator(object):
      def __init__(self, config, env_name, ide):
          self.config = config
          self.project_dir = os.path.dirname(config.path)
          self.env_name = str(env_name)
          self.ide = str(ide)
  
      @staticmethod
      def get_supported_ides():
          tpls_dir = os.path.join(fs.get_source_dir(), "ide", "tpls")
          return sorted(
              [
                  d
                  for d in os.listdir(tpls_dir)
                  if os.path.isdir(os.path.join(tpls_dir, d))
              ]
          )
  
      @staticmethod
      def filter_includes(includes_map, ignore_scopes=None, to_unix_path=True):
          ignore_scopes = ignore_scopes or []
          result = []
          for scope, includes in includes_map.items():
              if scope in ignore_scopes:
                  continue
              for include in includes:
                  if to_unix_path:
                      include = fs.to_unix_path(include)
                  if include not in result:
                      result.append(include)
          return result
  
      def _load_tplvars(self):
          tpl_vars = {
              "config": self.config,
              "systype": util.get_systype(),
              "project_name": os.path.basename(self.project_dir),
              "project_dir": self.project_dir,
              "env_name": self.env_name,
              "user_home_dir": os.path.realpath(fs.expanduser("~")),
              "platformio_path": sys.argv[0]
              if os.path.isfile(sys.argv[0])
              else where_is_program("platformio"),
              "env_path": os.getenv("PATH"),
              "env_pathsep": os.pathsep,
          }
  
          # default env configuration
          tpl_vars.update(self.config.items(env=self.env_name, as_dict=True))
          # build data
          tpl_vars.update(load_project_ide_data(self.project_dir, self.env_name) or {})
  
          with fs.cd(self.project_dir):
              tpl_vars.update(
                  {
                      "src_files": self.get_src_files(),
                      "project_src_dir": self.config.get_optional_dir("src"),
                      "project_lib_dir": self.config.get_optional_dir("lib"),
                      "project_test_dir": self.config.get_optional_dir("test"),
                      "project_libdeps_dir": os.path.join(
                          self.config.get_optional_dir("libdeps"), self.env_name
                      ),
                  }
              )
  
          for key, value in tpl_vars.items():
              if key.endswith(("_path", "_dir")):
                  tpl_vars[key] = fs.to_unix_path(value)
          for key in ("src_files", "libsource_dirs"):
              if key not in tpl_vars:
                  continue
              tpl_vars[key] = [fs.to_unix_path(inc) for inc in tpl_vars[key]]
  
          tpl_vars["to_unix_path"] = fs.to_unix_path
          tpl_vars["filter_includes"] = self.filter_includes
          return tpl_vars
  
      def get_src_files(self):
          result = []
          with fs.cd(self.project_dir):
              for root, _, files in os.walk(self.config.get_optional_dir("src")):
                  for f in files:
                      result.append(os.path.relpath(os.path.join(root, f)))
          return result
  
      def get_tpls(self):
          tpls = []
          tpls_dir = os.path.join(fs.get_source_dir(), "ide", "tpls", self.ide)
          for root, _, files in os.walk(tpls_dir):
              for f in files:
                  if not f.endswith(".tpl"):
                      continue
                  _relpath = root.replace(tpls_dir, "")
                  if _relpath.startswith(os.sep):
                      _relpath = _relpath[1:]
                  tpls.append((_relpath, os.path.join(root, f)))
          return tpls
  
      def generate(self):
          tpl_vars = self._load_tplvars()
          for tpl_relpath, tpl_path in self.get_tpls():
              dst_dir = self.project_dir
              if tpl_relpath:
                  dst_dir = os.path.join(self.project_dir, tpl_relpath)
                  if not os.path.isdir(dst_dir):
                      os.makedirs(dst_dir)
              file_name = os.path.basename(tpl_path)[:-4]
              contents = self._render_tpl(tpl_path, tpl_vars)
              self._merge_contents(os.path.join(dst_dir, file_name), contents)
  
      @staticmethod
      def _render_tpl(tpl_path, tpl_vars):
          with codecs.open(tpl_path, "r", encoding="utf8") as fp:
              return bottle.template(fp.read(), **tpl_vars)
  
      @staticmethod
      def _merge_contents(dst_path, contents):
          if os.path.basename(dst_path) == ".gitignore" and os.path.isfile(dst_path):
              return
          with codecs.open(dst_path, "w", encoding="utf8") as fp:
              fp.write(contents)
  